From 441a0d42b3cecb7cb4f1bc038c0b7f9d434f7814 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Wed, 17 Jul 2024 15:19:02 -0400 Subject: [PATCH 01/28] bare minimum wasm sqlite backend --- Cargo.lock | 88 ++++-- Cargo.toml | 2 +- bindings_ffi/Cargo.lock | 2 + xmtp_mls/Cargo.toml | 20 +- xmtp_mls/src/storage/mod.rs | 2 + xmtp_mls/src/storage/wasm_sqlite/backend.rs | 88 ++++++ .../src/storage/wasm_sqlite/connection.rs | 2 + .../wasm_sqlite/connection/bind_collector.rs | 251 ++++++++++++++++++ xmtp_mls/src/storage/wasm_sqlite/ffi.rs | 22 ++ xmtp_mls/src/storage/wasm_sqlite/mod.rs | 82 ++++++ .../wasm_sqlite/query_builder/limit_offset.rs | 127 +++++++++ .../storage/wasm_sqlite/query_builder/mod.rs | 44 +++ .../query_builder/query_fragment_impls.rs | 42 +++ .../wasm_sqlite/query_builder/returning.rs | 17 ++ .../src/storage/wasm_sqlite/sqlite_types.rs | 25 ++ 15 files changed, 784 insertions(+), 30 deletions(-) create mode 100644 xmtp_mls/src/storage/wasm_sqlite/backend.rs create mode 100644 xmtp_mls/src/storage/wasm_sqlite/connection.rs create mode 100644 xmtp_mls/src/storage/wasm_sqlite/connection/bind_collector.rs create mode 100644 xmtp_mls/src/storage/wasm_sqlite/ffi.rs create mode 100644 xmtp_mls/src/storage/wasm_sqlite/mod.rs create mode 100644 xmtp_mls/src/storage/wasm_sqlite/query_builder/limit_offset.rs create mode 100644 xmtp_mls/src/storage/wasm_sqlite/query_builder/mod.rs create mode 100644 xmtp_mls/src/storage/wasm_sqlite/query_builder/query_fragment_impls.rs create mode 100644 xmtp_mls/src/storage/wasm_sqlite/query_builder/returning.rs create mode 100644 xmtp_mls/src/storage/wasm_sqlite/sqlite_types.rs diff --git a/Cargo.lock b/Cargo.lock index 59f9f8b3a..7a3b7370b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1066,8 +1066,7 @@ dependencies = [ [[package]] name = "diesel" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35b696af9ff4c0d2a507db2c5faafa8aa0205e297e5f11e203a24226d5355e7a" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "diesel_derives", "libsqlite3-sys", @@ -1078,8 +1077,7 @@ dependencies = [ [[package]] name = "diesel_derives" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d6fdd83d5947068817016e939596d246e5367279453f2a3433287894f2f2996" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "diesel_table_macro_syntax", "dsl_auto_type", @@ -1091,8 +1089,7 @@ dependencies = [ [[package]] name = "diesel_migrations" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a73ce704bad4231f001bff3314d91dce4aba0770cee8b233991859abc15c1f6" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "diesel", "migrations_internals", @@ -1102,8 +1099,7 @@ dependencies = [ [[package]] name = "diesel_table_macro_syntax" version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "syn 2.0.66", ] @@ -1186,8 +1182,7 @@ checksum = "1435fa1053d8b2fbbe9be7e97eca7f33d37b28409959813daefc1446a14247f1" [[package]] name = "dsl_auto_type" version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab32c18ea6760d951659768a3e35ea72fc1ba0916d665a88dfe048b2a41e543f" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "darling", "either", @@ -1816,6 +1811,21 @@ dependencies = [ "spin 0.9.8", ] +[[package]] +name = "fluvio-wasm-timer" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b768c170dc045fa587a8f948c91f9bcfb87f774930477c6215addf54317f137f" +dependencies = [ + "futures", + "js-sys", + "parking_lot 0.11.2", + "pin-utils", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + [[package]] name = "fnv" version = "1.0.7" @@ -2586,6 +2596,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222" dependencies = [ "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", ] [[package]] @@ -2909,8 +2922,7 @@ checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d" [[package]] name = "migrations_internals" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd01039851e82f8799046eabbb354056283fb265c8ec0996af940f4e85a380ff" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "serde", "toml", @@ -2919,8 +2931,7 @@ dependencies = [ [[package]] name = "migrations_macros" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ffb161cc72176cb37aa47f1fc520d3ef02263d67d661f44f05d05a079e1237fd" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "migrations_internals", "proc-macro2", @@ -3246,6 +3257,8 @@ name = "openmls" version = "0.5.0" source = "git+https://github.com/xmtp/openmls?rev=9cb3207#9cb3207b077fcf6bc327408dfcf3df6237aec49c" dependencies = [ + "fluvio-wasm-timer", + "getrandom", "itertools 0.10.5", "log", "once_cell", @@ -3451,6 +3464,17 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "parking_lot" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99" +dependencies = [ + "instant", + "lock_api", + "parking_lot_core 0.8.6", +] + [[package]] name = "parking_lot" version = "0.12.3" @@ -3458,7 +3482,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27" dependencies = [ "lock_api", - "parking_lot_core", + "parking_lot_core 0.9.10", +] + +[[package]] +name = "parking_lot_core" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a2cfe6f0ad2bfc16aefa463b497d5c7a5ecd44a23efa72aa342d90177356dc" +dependencies = [ + "cfg-if", + "instant", + "libc", + "redox_syscall 0.2.16", + "smallvec", + "winapi", ] [[package]] @@ -3469,7 +3507,7 @@ checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" dependencies = [ "cfg-if", "libc", - "redox_syscall", + "redox_syscall 0.5.1", "smallvec", "windows-targets 0.52.5", ] @@ -4051,7 +4089,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "51de85fb3fb6524929c8a2eb85e6b6d363de4e8c48f9e2c2eac4944abc181c93" dependencies = [ "log", - "parking_lot", + "parking_lot 0.12.3", "scheduled-thread-pool", ] @@ -4120,6 +4158,15 @@ dependencies = [ "crossbeam-utils", ] +[[package]] +name = "redox_syscall" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a" +dependencies = [ + "bitflags 1.3.2", +] + [[package]] name = "redox_syscall" version = "0.5.1" @@ -4587,7 +4634,7 @@ version = "0.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3cbc66816425a074528352f5789333ecff06ca41b36b0b0efdfbb29edc391a19" dependencies = [ - "parking_lot", + "parking_lot 0.12.3", ] [[package]] @@ -4953,7 +5000,7 @@ checksum = "f91138e76242f575eb1d3b38b4f1362f10d3a43f47d182a5b359af488a02293b" dependencies = [ "new_debug_unreachable", "once_cell", - "parking_lot", + "parking_lot 0.12.3", "phf_shared 0.10.0", "precomputed-hash", ] @@ -5341,7 +5388,7 @@ dependencies = [ "libc", "mio", "num_cpus", - "parking_lot", + "parking_lot 0.12.3", "pin-project-lite", "signal-hook-registry", "socket2", @@ -6520,6 +6567,7 @@ dependencies = [ "tracing-log", "tracing-subscriber", "tracing-test", + "wasm-bindgen", "xmtp_api_grpc", "xmtp_cryptography", "xmtp_id", diff --git a/Cargo.toml b/Cargo.toml index 822b063b9..bd80ea6a7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -50,7 +50,7 @@ serde_json = "1.0" sha2 = "0.10.8" thiserror = "1.0" tls_codec = "0.4.0" -tokio = { version = "1.35.1", features = ["macros"] } +tokio = { version = "1.35.1", default-features = false } tonic = "^0.11" tracing = { version = "0.1", features = ["release_max_level_debug"] } tracing-subscriber = "0.3" diff --git a/bindings_ffi/Cargo.lock b/bindings_ffi/Cargo.lock index 9c6dbe3ad..ac3c0372e 100644 --- a/bindings_ffi/Cargo.lock +++ b/bindings_ffi/Cargo.lock @@ -4848,6 +4848,7 @@ dependencies = [ "futures-core", "pin-project-lite", "tokio", + "tokio-util", ] [[package]] @@ -5903,6 +5904,7 @@ dependencies = [ "thiserror", "tls_codec 0.4.0", "tokio", + "tokio-stream", "toml 0.8.8", "tracing", "xmtp_cryptography", diff --git a/xmtp_mls/Cargo.toml b/xmtp_mls/Cargo.toml index 26ac6b9ae..511302d5c 100644 --- a/xmtp_mls/Cargo.toml +++ b/xmtp_mls/Cargo.toml @@ -11,9 +11,10 @@ path = "src/bin/update-schema.rs" [features] default = ["native"] grpc = ["xmtp_proto/grpc"] -native = ["libsqlite3-sys/bundled-sqlcipher-vendored-openssl"] +native = ["libsqlite3-sys/bundled-sqlcipher-vendored-openssl", "diesel_migrations/sqlite", "diesel/sqlite", "diesel/returning_clauses_for_sqlite_3_35", "tokio/rt-multi-thread", "tokio/macros"] test-utils = ["xmtp_api_grpc"] bench = ["test-utils", "indicatif", "tracing-subscriber", "anyhow", "tracing-flame", "once_cell"] +web = ["wasm-bindgen", "diesel/i-implement-a-third-party-backend-and-opt-into-breaking-changes", "openmls/js", "tokio/macros"] [dependencies] aes = "0.8.4" @@ -21,18 +22,13 @@ aes-gcm = { version = "0.10.3", features = ["std"] } async-trait.workspace = true bincode = "1.3.3" chrono = { workspace = true } -diesel = { version = "2.2", features = [ - "sqlite", - "r2d2", - "returning_clauses_for_sqlite_3_35", -] } -diesel_migrations = { version = "2.1.0", features = ["sqlite"] } +diesel = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend", features = ["r2d2"] } +diesel_migrations = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend" } ed25519-dalek = "2.1.1" ethers.workspace = true ethers-core.workspace = true futures.workspace = true hex.workspace = true -libsqlite3-sys = { version = "0.28.0", optional = true } log.workspace = true tracing.workspace = true openmls = { workspace = true, features = ["test-utils"] } @@ -49,7 +45,7 @@ sha2.workspace = true smart-default = "0.7.1" thiserror = { workspace = true } tls_codec = { workspace = true } -tokio = { workspace = true, features = ["rt-multi-thread"] } +tokio = { workspace = true, default-features = false } tokio-stream = { version = "0.1", features = ["sync"] } toml = "0.8.4" xmtp_cryptography = { workspace = true } @@ -57,6 +53,12 @@ xmtp_id = { path = "../xmtp_id" } xmtp_proto = { workspace = true, features = ["proto_full", "convert"] } xmtp_v2 = { path = "../xmtp_v2" } +# Native +libsqlite3-sys = { version = "0.28.0", optional = true } + +# Web +wasm-bindgen = { version = "0.2", optional = true } + # Test/Bench Utils xmtp_api_grpc = { path = "../xmtp_api_grpc", optional = true } tracing-subscriber = { workspace = true, optional = true } diff --git a/xmtp_mls/src/storage/mod.rs b/xmtp_mls/src/storage/mod.rs index 82ca3f125..e630023c4 100644 --- a/xmtp_mls/src/storage/mod.rs +++ b/xmtp_mls/src/storage/mod.rs @@ -2,6 +2,8 @@ mod encrypted_store; mod errors; mod serialization; pub mod sql_key_store; +#[cfg(feature = "web")] +pub mod wasm_sqlite; pub use encrypted_store::*; pub use errors::StorageError; diff --git a/xmtp_mls/src/storage/wasm_sqlite/backend.rs b/xmtp_mls/src/storage/wasm_sqlite/backend.rs new file mode 100644 index 000000000..9e251eff6 --- /dev/null +++ b/xmtp_mls/src/storage/wasm_sqlite/backend.rs @@ -0,0 +1,88 @@ +//! The SQLite backend + +use super::connection::SqliteBindCollector; +use super::query_builder::SqliteQueryBuilder; +use diesel::backend::*; +use diesel::sql_types::TypeMetadata; + +/// The SQLite backend +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, Default)] +pub struct WasmSqlite; + +/// Determines how a bind parameter is given to SQLite +/// +/// Diesel deals with bind parameters after serialization as opaque blobs of +/// bytes. However, SQLite instead has several functions where it expects the +/// relevant C types. +/// +/// The variants of this struct determine what bytes are expected from +/// `ToSql` impls. +#[allow(missing_debug_implementations)] +#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)] +pub enum SqliteType { + /// Bind using `sqlite3_bind_blob` + Binary, + /// Bind using `sqlite3_bind_text` + Text, + /// `bytes` should contain an `f32` + Float, + /// `bytes` should contain an `f64` + Double, + /// `bytes` should contain an `i16` + SmallInt, + /// `bytes` should contain an `i32` + Integer, + /// `bytes` should contain an `i64` + Long, +} + +impl Backend for WasmSqlite { + type QueryBuilder = SqliteQueryBuilder; + type RawValue<'a> = (); + // type RawValue<'a> = SqliteValue<'a, 'a, 'a>; + type BindCollector<'a> = SqliteBindCollector<'a>; +} + +impl TypeMetadata for WasmSqlite { + type TypeMetadata = SqliteType; + type MetadataLookup = (); +} + +impl SqlDialect for WasmSqlite { + #[cfg(not(feature = "returning_clauses_for_sqlite_3_35"))] + type ReturningClause = sql_dialect::returning_clause::DoesNotSupportReturningClause; + #[cfg(feature = "returning_clauses_for_sqlite_3_35")] + type ReturningClause = SqliteReturningClause; + + type OnConflictClause = SqliteOnConflictClause; + + type InsertWithDefaultKeyword = + sql_dialect::default_keyword_for_insert::DoesNotSupportDefaultKeyword; + type BatchInsertSupport = SqliteBatchInsert; + type ConcatClause = sql_dialect::concat_clause::ConcatWithPipesClause; + type DefaultValueClauseForInsert = sql_dialect::default_value_clause::AnsiDefaultValueClause; + + type EmptyFromClauseSyntax = sql_dialect::from_clause_syntax::AnsiSqlFromClauseSyntax; + type SelectStatementSyntax = sql_dialect::select_statement_syntax::AnsiSqlSelectStatement; + + type ExistsSyntax = sql_dialect::exists_syntax::AnsiSqlExistsSyntax; + type ArrayComparison = sql_dialect::array_comparison::AnsiSqlArrayComparison; + type AliasSyntax = sql_dialect::alias_syntax::AsAliasSyntax; +} + +impl DieselReserveSpecialization for WasmSqlite {} +impl TrustedBackend for WasmSqlite {} + +#[derive(Debug, Copy, Clone)] +pub struct SqliteOnConflictClause; + +impl sql_dialect::on_conflict_clause::SupportsOnConflictClause for SqliteOnConflictClause {} +impl sql_dialect::on_conflict_clause::PgLikeOnConflictClause for SqliteOnConflictClause {} + +#[derive(Debug, Copy, Clone)] +pub struct SqliteBatchInsert; + +#[derive(Debug, Copy, Clone)] +pub struct SqliteReturningClause; + +impl sql_dialect::returning_clause::SupportsReturningClause for SqliteReturningClause {} diff --git a/xmtp_mls/src/storage/wasm_sqlite/connection.rs b/xmtp_mls/src/storage/wasm_sqlite/connection.rs new file mode 100644 index 000000000..3f31e1532 --- /dev/null +++ b/xmtp_mls/src/storage/wasm_sqlite/connection.rs @@ -0,0 +1,2 @@ +pub mod bind_collector; +pub use bind_collector::*; diff --git a/xmtp_mls/src/storage/wasm_sqlite/connection/bind_collector.rs b/xmtp_mls/src/storage/wasm_sqlite/connection/bind_collector.rs new file mode 100644 index 000000000..68a827d08 --- /dev/null +++ b/xmtp_mls/src/storage/wasm_sqlite/connection/bind_collector.rs @@ -0,0 +1,251 @@ +use crate::storage::wasm_sqlite::{SqliteType, WasmSqlite}; +use diesel::query_builder::{BindCollector, MoveableBindCollector}; +use diesel::result::QueryResult; +use diesel::serialize::{IsNull, Output}; +use diesel::sql_types::HasSqlType; + +#[derive(Debug, Default)] +pub struct SqliteBindCollector<'a> { + pub(in crate::storage::wasm_sqlite) binds: Vec<(InternalSqliteBindValue<'a>, SqliteType)>, +} + +impl SqliteBindCollector<'_> { + pub(in crate::storage::wasm_sqlite) fn new() -> Self { + Self { binds: Vec::new() } + } +} + +/// This type represents a value bound to +/// a sqlite prepared statement +/// +/// It can be constructed via the various `From` implementations +#[derive(Debug)] +pub struct SqliteBindValue<'a> { + pub(in crate::storage::wasm_sqlite) inner: InternalSqliteBindValue<'a>, +} + +impl<'a> From for SqliteBindValue<'a> { + fn from(i: i32) -> Self { + Self { + inner: InternalSqliteBindValue::I32(i), + } + } +} + +impl<'a> From for SqliteBindValue<'a> { + fn from(i: i64) -> Self { + Self { + inner: InternalSqliteBindValue::I64(i), + } + } +} + +impl<'a> From for SqliteBindValue<'a> { + fn from(f: f64) -> Self { + Self { + inner: InternalSqliteBindValue::F64(f), + } + } +} + +impl<'a, T> From> for SqliteBindValue<'a> +where + T: Into>, +{ + fn from(o: Option) -> Self { + match o { + Some(v) => v.into(), + None => Self { + inner: InternalSqliteBindValue::Null, + }, + } + } +} + +impl<'a> From<&'a str> for SqliteBindValue<'a> { + fn from(s: &'a str) -> Self { + Self { + inner: InternalSqliteBindValue::BorrowedString(s), + } + } +} + +impl<'a> From for SqliteBindValue<'a> { + fn from(s: String) -> Self { + Self { + inner: InternalSqliteBindValue::String(s.into_boxed_str()), + } + } +} + +impl<'a> From> for SqliteBindValue<'a> { + fn from(b: Vec) -> Self { + Self { + inner: InternalSqliteBindValue::Binary(b.into_boxed_slice()), + } + } +} + +impl<'a> From<&'a [u8]> for SqliteBindValue<'a> { + fn from(b: &'a [u8]) -> Self { + Self { + inner: InternalSqliteBindValue::BorrowedBinary(b), + } + } +} + +#[derive(Debug)] +pub(crate) enum InternalSqliteBindValue<'a> { + BorrowedString(&'a str), + String(Box), + BorrowedBinary(&'a [u8]), + Binary(Box<[u8]>), + I32(i32), + I64(i64), + F64(f64), + Null, +} + +impl std::fmt::Display for InternalSqliteBindValue<'_> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let n = match self { + InternalSqliteBindValue::BorrowedString(_) | InternalSqliteBindValue::String(_) => { + "Text" + } + InternalSqliteBindValue::BorrowedBinary(_) | InternalSqliteBindValue::Binary(_) => { + "Binary" + } + InternalSqliteBindValue::I32(_) | InternalSqliteBindValue::I64(_) => "Integer", + InternalSqliteBindValue::F64(_) => "Float", + InternalSqliteBindValue::Null => "Null", + }; + f.write_str(n) + } +} + +impl InternalSqliteBindValue<'_> { + #[allow(unsafe_code)] // ffi function calls + pub(in crate::storage::wasm_sqlite) fn result_of(self, ctx: &mut i32) { + use crate::storage::wasm_sqlite::ffi; + match self { + InternalSqliteBindValue::BorrowedString(s) => { + ffi::sqlite3_result_text(*ctx, s.to_string()) + } + InternalSqliteBindValue::String(s) => ffi::sqlite3_result_text(*ctx, s.to_string()), + InternalSqliteBindValue::Binary(b) => ffi::sqlite3_result_blob(*ctx, b.to_vec()), + InternalSqliteBindValue::BorrowedBinary(b) => { + ffi::sqlite3_result_blob(*ctx, b.to_vec()) + } + InternalSqliteBindValue::I32(i) => ffi::sqlite3_result_int(*ctx, i), + InternalSqliteBindValue::I64(l) => ffi::sqlite3_result_int64(*ctx, l), + InternalSqliteBindValue::F64(d) => ffi::sqlite3_result_double(*ctx, d), + InternalSqliteBindValue::Null => ffi::sqlite3_result_null(*ctx), + } + } +} + +impl<'a> BindCollector<'a, WasmSqlite> for SqliteBindCollector<'a> { + type Buffer = SqliteBindValue<'a>; + + fn push_bound_value(&mut self, bind: &'a U, metadata_lookup: &mut ()) -> QueryResult<()> + where + WasmSqlite: diesel::sql_types::HasSqlType, + U: diesel::serialize::ToSql + ?Sized, + { + let value = SqliteBindValue { + inner: InternalSqliteBindValue::Null, + }; + let mut to_sql_output = Output::new(value, metadata_lookup); + let is_null = bind + .to_sql(&mut to_sql_output) + .map_err(diesel::result::Error::SerializationError)?; + let bind = to_sql_output.into_inner(); + let metadata = WasmSqlite::metadata(metadata_lookup); + self.binds.push(( + match is_null { + IsNull::No => bind.inner, + IsNull::Yes => InternalSqliteBindValue::Null, + }, + metadata, + )); + Ok(()) + } + + fn push_null_value(&mut self, metadata: SqliteType) -> QueryResult<()> { + self.binds.push((InternalSqliteBindValue::Null, metadata)); + Ok(()) + } +} + +#[derive(Debug)] +enum OwnedSqliteBindValue { + String(Box), + Binary(Box<[u8]>), + I32(i32), + I64(i64), + F64(f64), + Null, +} + +impl<'a> std::convert::From<&InternalSqliteBindValue<'a>> for OwnedSqliteBindValue { + fn from(value: &InternalSqliteBindValue<'a>) -> Self { + match value { + InternalSqliteBindValue::String(s) => Self::String(s.clone()), + InternalSqliteBindValue::BorrowedString(s) => { + Self::String(String::from(*s).into_boxed_str()) + } + InternalSqliteBindValue::Binary(b) => Self::Binary(b.clone()), + InternalSqliteBindValue::BorrowedBinary(s) => { + Self::Binary(Vec::from(*s).into_boxed_slice()) + } + InternalSqliteBindValue::I32(val) => Self::I32(*val), + InternalSqliteBindValue::I64(val) => Self::I64(*val), + InternalSqliteBindValue::F64(val) => Self::F64(*val), + InternalSqliteBindValue::Null => Self::Null, + } + } +} + +impl<'a> std::convert::From<&OwnedSqliteBindValue> for InternalSqliteBindValue<'a> { + fn from(value: &OwnedSqliteBindValue) -> Self { + match value { + OwnedSqliteBindValue::String(s) => Self::String(s.clone()), + OwnedSqliteBindValue::Binary(b) => Self::Binary(b.clone()), + OwnedSqliteBindValue::I32(val) => Self::I32(*val), + OwnedSqliteBindValue::I64(val) => Self::I64(*val), + OwnedSqliteBindValue::F64(val) => Self::F64(*val), + OwnedSqliteBindValue::Null => Self::Null, + } + } +} + +#[derive(Debug)] +/// Sqlite bind collector data that is movable across threads +pub struct SqliteBindCollectorData { + binds: Vec<(OwnedSqliteBindValue, SqliteType)>, +} + +impl MoveableBindCollector for SqliteBindCollector<'_> { + type BindData = SqliteBindCollectorData; + + fn moveable(&self) -> Self::BindData { + let mut binds = Vec::with_capacity(self.binds.len()); + for b in self + .binds + .iter() + .map(|(bind, tpe)| (OwnedSqliteBindValue::from(bind), *tpe)) + { + binds.push(b); + } + SqliteBindCollectorData { binds } + } + + fn append_bind_data(&mut self, from: &Self::BindData) { + self.binds.reserve_exact(from.binds.len()); + self.binds.extend( + from.binds + .iter() + .map(|(bind, tpe)| (InternalSqliteBindValue::from(bind), *tpe)), + ); + } +} diff --git a/xmtp_mls/src/storage/wasm_sqlite/ffi.rs b/xmtp_mls/src/storage/wasm_sqlite/ffi.rs new file mode 100644 index 000000000..1f4be65be --- /dev/null +++ b/xmtp_mls/src/storage/wasm_sqlite/ffi.rs @@ -0,0 +1,22 @@ +use wasm_bindgen::{prelude::*, JsValue}; + +/// Simple Connection +#[wasm_bindgen] +extern "C" { + #[wasm_bindgen(catch)] + pub fn batch_execute(query: &str) -> Result<(), JsValue>; + + #[wasm_bindgen(catch)] + pub fn establish(database_url: &str) -> Result<(), JsValue>; +} + +/// Direct Shim for was-sqlite +#[wasm_bindgen] +extern "C" { + pub fn sqlite3_result_text(context: i32, value: String); + pub fn sqlite3_result_int(context: i32, value: i32); + pub fn sqlite3_result_int64(context: i32, value: i64); + pub fn sqlite3_result_double(context: i32, value: f64); + pub fn sqlite3_result_blob(context: i32, value: Vec); + pub fn sqlite3_result_null(context: i32); +} diff --git a/xmtp_mls/src/storage/wasm_sqlite/mod.rs b/xmtp_mls/src/storage/wasm_sqlite/mod.rs new file mode 100644 index 000000000..f6033799f --- /dev/null +++ b/xmtp_mls/src/storage/wasm_sqlite/mod.rs @@ -0,0 +1,82 @@ +//! Module for an SQLite backend accesible from the web. +pub mod backend; +pub mod connection; +pub mod ffi; +pub mod query_builder; +pub mod sqlite_types; + +use diesel::{ + connection::{AnsiTransactionManager, Instrumentation, SimpleConnection, TransactionManager}, + query_builder::{QueryFragment, QueryId}, + result::QueryResult, + Connection, +}; +use wasm_bindgen::JsValue; + +pub use backend::{SqliteType, WasmSqlite}; +pub struct WasmSqliteConnection {} +#[derive(Debug)] +pub struct WasmSqliteError(JsValue); + +impl SimpleConnection for WasmSqliteConnection { + fn batch_execute(&mut self, query: &str) -> diesel::prelude::QueryResult<()> { + ffi::batch_execute(query) + .map_err(WasmSqliteError::from) + .map_err(Into::into) + } +} + +impl diesel::connection::ConnectionSealed for WasmSqliteConnection {} + +impl Connection for WasmSqliteConnection { + type Backend = WasmSqlite; + type TransactionManager = AnsiTransactionManager; + + fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { + ffi::establish(database_url) + .map_err(WasmSqliteError::from) + .map_err(Into::::into)?; + Ok(WasmSqliteConnection {}) + } + + fn execute_returning_count(&mut self, source: &T) -> QueryResult + where + T: QueryFragment + QueryId, + { + todo!() + } + + fn transaction_state( + &mut self, + ) -> &mut >::TransactionStateData { + todo!() + } + + fn instrumentation(&mut self) -> &mut dyn Instrumentation { + todo!() + } + + fn set_instrumentation(&mut self, instrumentation: impl diesel::connection::Instrumentation) { + todo!() + } +} + +impl From for diesel::result::Error { + fn from(value: WasmSqliteError) -> diesel::result::Error { + log::error!("NOT IMPLEMENTED, {:?}", value); + diesel::result::Error::NotFound + } +} + +impl From for diesel::result::ConnectionError { + fn from(value: WasmSqliteError) -> diesel::result::ConnectionError { + log::error!("NOT IMPLEMENTED, {:?}", value); + diesel::result::ConnectionError::BadConnection("Not implemented".to_string()) + } +} + +impl From for WasmSqliteError { + fn from(err: JsValue) -> WasmSqliteError { + WasmSqliteError(err) + } +} diff --git a/xmtp_mls/src/storage/wasm_sqlite/query_builder/limit_offset.rs b/xmtp_mls/src/storage/wasm_sqlite/query_builder/limit_offset.rs new file mode 100644 index 000000000..734a933a3 --- /dev/null +++ b/xmtp_mls/src/storage/wasm_sqlite/query_builder/limit_offset.rs @@ -0,0 +1,127 @@ +use crate::storage::wasm_sqlite::WasmSqlite; +use diesel::query_builder::{AstPass, IntoBoxedClause, QueryFragment}; +use diesel::query_builder::{BoxedLimitOffsetClause, LimitOffsetClause}; +use diesel::query_builder::{LimitClause, NoLimitClause}; +use diesel::query_builder::{NoOffsetClause, OffsetClause}; +use diesel::result::QueryResult; + +impl QueryFragment for LimitOffsetClause { + fn walk_ast<'b>(&'b self, _out: AstPass<'_, 'b, WasmSqlite>) -> QueryResult<()> { + Ok(()) + } +} + +impl QueryFragment for LimitOffsetClause, NoOffsetClause> +where + LimitClause: QueryFragment, +{ + fn walk_ast<'b>(&'b self, out: AstPass<'_, 'b, WasmSqlite>) -> QueryResult<()> { + self.limit_clause.walk_ast(out)?; + Ok(()) + } +} + +impl QueryFragment for LimitOffsetClause> +where + OffsetClause: QueryFragment, +{ + fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, WasmSqlite>) -> QueryResult<()> { + // Sqlite requires a limit clause in front of any offset clause + // using `LIMIT -1` is the same as not having any limit clause + // https://sqlite.org/lang_select.html + out.push_sql(" LIMIT -1 "); + self.offset_clause.walk_ast(out)?; + Ok(()) + } +} + +impl QueryFragment for LimitOffsetClause, OffsetClause> +where + LimitClause: QueryFragment, + OffsetClause: QueryFragment, +{ + fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, WasmSqlite>) -> QueryResult<()> { + self.limit_clause.walk_ast(out.reborrow())?; + self.offset_clause.walk_ast(out.reborrow())?; + Ok(()) + } +} + +impl<'a> QueryFragment for BoxedLimitOffsetClause<'a, WasmSqlite> { + fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, WasmSqlite>) -> QueryResult<()> { + match (self.limit.as_ref(), self.offset.as_ref()) { + (Some(limit), Some(offset)) => { + limit.walk_ast(out.reborrow())?; + offset.walk_ast(out.reborrow())?; + } + (Some(limit), None) => { + limit.walk_ast(out.reborrow())?; + } + (None, Some(offset)) => { + // See the `QueryFragment` implementation for `LimitOffsetClause` for details. + out.push_sql(" LIMIT -1 "); + offset.walk_ast(out.reborrow())?; + } + (None, None) => {} + } + Ok(()) + } +} + +// Have explicit impls here because we need to set `Some`/`None` for the clauses +// correspondingly, otherwise we cannot match on it in the `QueryFragment` impl +// above +impl<'a> IntoBoxedClause<'a, WasmSqlite> for LimitOffsetClause { + type BoxedClause = BoxedLimitOffsetClause<'a, WasmSqlite>; + + fn into_boxed(self) -> Self::BoxedClause { + BoxedLimitOffsetClause { + limit: None, + offset: None, + } + } +} + +impl<'a, L> IntoBoxedClause<'a, WasmSqlite> for LimitOffsetClause, NoOffsetClause> +where + L: QueryFragment + Send + 'a, +{ + type BoxedClause = BoxedLimitOffsetClause<'a, WasmSqlite>; + + fn into_boxed(self) -> Self::BoxedClause { + BoxedLimitOffsetClause { + limit: Some(Box::new(self.limit_clause)), + offset: None, + } + } +} + +impl<'a, O> IntoBoxedClause<'a, WasmSqlite> for LimitOffsetClause> +where + O: QueryFragment + Send + 'a, +{ + type BoxedClause = BoxedLimitOffsetClause<'a, WasmSqlite>; + + fn into_boxed(self) -> Self::BoxedClause { + BoxedLimitOffsetClause { + limit: None, + offset: Some(Box::new(self.offset_clause)), + } + } +} + +impl<'a, L, O> IntoBoxedClause<'a, WasmSqlite> + for LimitOffsetClause, OffsetClause> +where + L: QueryFragment + Send + 'a, + O: QueryFragment + Send + 'a, +{ + type BoxedClause = BoxedLimitOffsetClause<'a, WasmSqlite>; + + fn into_boxed(self) -> Self::BoxedClause { + BoxedLimitOffsetClause { + limit: Some(Box::new(self.limit_clause)), + offset: Some(Box::new(self.offset_clause)), + } + } +} diff --git a/xmtp_mls/src/storage/wasm_sqlite/query_builder/mod.rs b/xmtp_mls/src/storage/wasm_sqlite/query_builder/mod.rs new file mode 100644 index 000000000..8bf48119b --- /dev/null +++ b/xmtp_mls/src/storage/wasm_sqlite/query_builder/mod.rs @@ -0,0 +1,44 @@ +//! The SQLite query builder + +use super::backend::WasmSqlite; +use diesel::query_builder::QueryBuilder; +use diesel::result::QueryResult; + +mod limit_offset; +mod query_fragment_impls; +mod returning; + +/// Constructs SQL queries for use with the SQLite backend +#[allow(missing_debug_implementations)] +#[derive(Default)] +pub struct SqliteQueryBuilder { + sql: String, +} + +impl SqliteQueryBuilder { + /// Construct a new query builder with an empty query + pub fn new() -> Self { + SqliteQueryBuilder::default() + } +} + +impl QueryBuilder for SqliteQueryBuilder { + fn push_sql(&mut self, sql: &str) { + self.sql.push_str(sql); + } + + fn push_identifier(&mut self, identifier: &str) -> QueryResult<()> { + self.push_sql("`"); + self.push_sql(&identifier.replace('`', "``")); + self.push_sql("`"); + Ok(()) + } + + fn push_bind_param(&mut self) { + self.push_sql("?"); + } + + fn finish(self) -> String { + self.sql + } +} diff --git a/xmtp_mls/src/storage/wasm_sqlite/query_builder/query_fragment_impls.rs b/xmtp_mls/src/storage/wasm_sqlite/query_builder/query_fragment_impls.rs new file mode 100644 index 000000000..4d840529e --- /dev/null +++ b/xmtp_mls/src/storage/wasm_sqlite/query_builder/query_fragment_impls.rs @@ -0,0 +1,42 @@ +/* +// use diesel::query_builder::into_conflict_clause::OnConflictSelectWrapper; +// use diesel::query_builder::where_clause::BoxedWhereClause; +use diesel::query_builder::AstPass; +use diesel::query_builder::BoxedSelectStatement; +use diesel::query_builder::QueryFragment; +use diesel::query_builder::SelectStatement; +// use diesel::query_builder::WhereClause; +use crate::storage::wasm_sqlite::WasmSqlite; +use diesel::result::QueryResult; + +// The corresponding impl for`NoWhereClause` is missing because of +// https://www.sqlite.org/lang_UPSERT.html (Parsing Ambiguity) +impl QueryFragment + for OnConflictSelectWrapper, O, LOf, G, H, LC>> +where + SelectStatement, O, LOf, G, H, LC>: QueryFragment, +{ + fn walk_ast<'b>(&'b self, out: AstPass<'_, 'b, WasmSqlite>) -> QueryResult<()> { + self.0.walk_ast(out) + } +} + +// #[cfg(feature = "sqlite")] +impl<'a, ST, QS, GB> QueryFragment + for OnConflictSelectWrapper> +where + BoxedSelectStatement<'a, ST, QS, WasmSqlite, GB>: QueryFragment, + QS: QueryFragment, +{ + fn walk_ast<'b>(&'b self, pass: AstPass<'_, 'b, WasmSqlite>) -> QueryResult<()> { + // https://www.sqlite.org/lang_UPSERT.html (Parsing Ambiguity) + self.0.build_query(pass, |where_clause, mut pass| { + match where_clause { + BoxedWhereClause::None => pass.push_sql(" WHERE 1=1 "), + w => w.walk_ast(pass.reborrow())?, + } + Ok(()) + }) + } +} +*/ diff --git a/xmtp_mls/src/storage/wasm_sqlite/query_builder/returning.rs b/xmtp_mls/src/storage/wasm_sqlite/query_builder/returning.rs new file mode 100644 index 000000000..fef4c8751 --- /dev/null +++ b/xmtp_mls/src/storage/wasm_sqlite/query_builder/returning.rs @@ -0,0 +1,17 @@ +use crate::storage::wasm_sqlite::backend::{SqliteReturningClause, WasmSqlite}; +// use diesel::backend::Backend; +use diesel::query_builder::ReturningClause; +use diesel::query_builder::{AstPass, QueryFragment}; +use diesel::result::QueryResult; + +impl QueryFragment for ReturningClause +where + Expr: QueryFragment, +{ + fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, WasmSqlite>) -> QueryResult<()> { + out.skip_from(true); + out.push_sql(" RETURNING "); + self.0.walk_ast(out.reborrow())?; + Ok(()) + } +} diff --git a/xmtp_mls/src/storage/wasm_sqlite/sqlite_types.rs b/xmtp_mls/src/storage/wasm_sqlite/sqlite_types.rs new file mode 100644 index 000000000..75c2d0d04 --- /dev/null +++ b/xmtp_mls/src/storage/wasm_sqlite/sqlite_types.rs @@ -0,0 +1,25 @@ +use super::backend::{SqliteType, WasmSqlite}; +use diesel::sql_types::*; + +macro_rules! impl_has_sql_type { + ($type:ty, $sql_type:expr) => { + impl HasSqlType<$type> for WasmSqlite { + fn metadata(_: &mut ()) -> SqliteType { + $sql_type + } + } + }; +} + +impl_has_sql_type!(Bool, SqliteType::Integer); +impl_has_sql_type!(SmallInt, SqliteType::SmallInt); +impl_has_sql_type!(Integer, SqliteType::Integer); +impl_has_sql_type!(BigInt, SqliteType::Long); +impl_has_sql_type!(Float, SqliteType::Float); +impl_has_sql_type!(Double, SqliteType::Double); +impl_has_sql_type!(Numeric, SqliteType::Double); +impl_has_sql_type!(Text, SqliteType::Text); +impl_has_sql_type!(Binary, SqliteType::Binary); +impl_has_sql_type!(Date, SqliteType::Text); +impl_has_sql_type!(Time, SqliteType::Text); +impl_has_sql_type!(Timestamp, SqliteType::Text); From 797b1bd245875c7e111c6d52330c38e74a312dec Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Wed, 17 Jul 2024 15:25:55 -0400 Subject: [PATCH 02/28] make the wasm sqlite backend its own crate --- Cargo.lock | 559 ++++++++++-------- Cargo.toml | 2 +- diesel-wasm-sqlite/Cargo.toml | 6 + diesel-wasm-sqlite/README.md | 1 + .../src}/backend.rs | 0 .../src}/connection.rs | 0 .../src}/connection/bind_collector.rs | 0 .../src}/ffi.rs | 0 diesel-wasm-sqlite/src/lib.rs | 14 + .../src}/mod.rs | 0 .../src}/query_builder/limit_offset.rs | 0 .../src}/query_builder/mod.rs | 0 .../query_builder/query_fragment_impls.rs | 0 .../src}/query_builder/returning.rs | 0 .../src}/sqlite_types.rs | 0 xmtp_mls/src/storage/mod.rs | 2 - 16 files changed, 322 insertions(+), 262 deletions(-) create mode 100644 diesel-wasm-sqlite/Cargo.toml create mode 100644 diesel-wasm-sqlite/README.md rename {xmtp_mls/src/storage/wasm_sqlite => diesel-wasm-sqlite/src}/backend.rs (100%) rename {xmtp_mls/src/storage/wasm_sqlite => diesel-wasm-sqlite/src}/connection.rs (100%) rename {xmtp_mls/src/storage/wasm_sqlite => diesel-wasm-sqlite/src}/connection/bind_collector.rs (100%) rename {xmtp_mls/src/storage/wasm_sqlite => diesel-wasm-sqlite/src}/ffi.rs (100%) create mode 100644 diesel-wasm-sqlite/src/lib.rs rename {xmtp_mls/src/storage/wasm_sqlite => diesel-wasm-sqlite/src}/mod.rs (100%) rename {xmtp_mls/src/storage/wasm_sqlite => diesel-wasm-sqlite/src}/query_builder/limit_offset.rs (100%) rename {xmtp_mls/src/storage/wasm_sqlite => diesel-wasm-sqlite/src}/query_builder/mod.rs (100%) rename {xmtp_mls/src/storage/wasm_sqlite => diesel-wasm-sqlite/src}/query_builder/query_fragment_impls.rs (100%) rename {xmtp_mls/src/storage/wasm_sqlite => diesel-wasm-sqlite/src}/query_builder/returning.rs (100%) rename {xmtp_mls/src/storage/wasm_sqlite => diesel-wasm-sqlite/src}/sqlite_types.rs (100%) diff --git a/Cargo.lock b/Cargo.lock index 7a3b7370b..127a89a12 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -14,9 +14,9 @@ dependencies = [ [[package]] name = "addr2line" -version = "0.21.0" +version = "0.22.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb" +checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678" dependencies = [ "gimli", ] @@ -133,9 +133,9 @@ dependencies = [ [[package]] name = "anstyle-query" -version = "1.0.3" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a64c907d4e79225ac72e2a354c9ce84d50ebb4586dee56c82b3ee73004f537f5" +checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391" dependencies = [ "windows-sys 0.52.0", ] @@ -225,18 +225,18 @@ checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] name = "async-trait" -version = "0.1.80" +version = "0.1.81" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca" +checksum = "6e0c28dcc82d7c8ead5cb13beb15405b57b8546e93215673ff8ca0349a028107" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -264,7 +264,7 @@ checksum = "3c87f3f15e7794432337fc718554eaa4dc8f04c9677a950ffe366f20a162ae42" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -286,7 +286,7 @@ dependencies = [ "futures-util", "http 0.2.12", "http-body 0.4.6", - "hyper 0.14.28", + "hyper 0.14.30", "itoa", "matchit", "memchr", @@ -295,7 +295,7 @@ dependencies = [ "pin-project-lite", "rustversion", "serde", - "sync_wrapper", + "sync_wrapper 0.1.2", "tower", "tower-layer", "tower-service", @@ -320,9 +320,9 @@ dependencies = [ [[package]] name = "backtrace" -version = "0.3.71" +version = "0.3.73" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d" +checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a" dependencies = [ "addr2line", "cc", @@ -407,9 +407,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.5.0" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" [[package]] name = "bitvec" @@ -471,9 +471,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "bytes" -version = "1.6.0" +version = "1.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" +checksum = "a12916984aab3fa6e39d655a33e09c0071eb36d6ab3aea5c2d78551f1df6d952" dependencies = [ "serde", ] @@ -539,13 +539,12 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" [[package]] name = "cc" -version = "1.0.98" +version = "1.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41c270e7540d725e65ac7f1b212ac8ce349719624d7bcff99f8e2e488e8cf03f" +checksum = "324c74f2155653c90b04f25b2a47a8a631360cb908f92a772695f430c7e31052" dependencies = [ "jobserver", "libc", - "once_cell", ] [[package]] @@ -589,7 +588,7 @@ dependencies = [ "js-sys", "num-traits", "wasm-bindgen", - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -632,9 +631,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.4" +version = "4.5.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90bc066a67923782aa8515dbaea16946c5bcc5addbd668bb80af688e53e548a0" +checksum = "64acc1846d54c1fe936a78dc189c34e28d3f5afc348403f28ecf53660b9b8462" dependencies = [ "clap_builder", "clap_derive", @@ -642,9 +641,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.2" +version = "4.5.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae129e2e766ae0ec03484e609954119f123cc1fe650337e155d03b022f24f7b4" +checksum = "6fb8393d67ba2e7bfaf28a23458e4e2b543cc73a99595511eb207fdb8aede942" dependencies = [ "anstream", "anstyle", @@ -654,21 +653,21 @@ dependencies = [ [[package]] name = "clap_derive" -version = "4.5.4" +version = "4.5.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "528131438037fd55894f62d6e9f068b8f45ac57ffa77517819645d10aed04f64" +checksum = "2bac35c6dafb060fd4d275d9a4ffae97917c13a6327903a8be2153cd964f7085" dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] name = "clap_lex" -version = "0.7.0" +version = "0.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce" +checksum = "4b82cf0babdbd58558212896d1a4272303a57bdb245c2bf1147185fb45640e70" [[package]] name = "coins-bip32" @@ -763,9 +762,9 @@ dependencies = [ [[package]] name = "const-hex" -version = "1.11.4" +version = "1.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70ff96486ccc291d36a958107caf2c0af8c78c0af7d31ae2f35ce055130de1a6" +checksum = "94fb8a24a26d37e1ffd45343323dc9fe6654ceea44c12f2fcb3d7ac29e610bc6" dependencies = [ "cfg-if", "cpufeatures", @@ -941,7 +940,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "edb49164822f3ee45b17acd4a208cfc1251410cf0cad9a833234c9890774dd9f" dependencies = [ "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -955,16 +954,15 @@ dependencies = [ [[package]] name = "curve25519-dalek" -version = "4.1.2" +version = "4.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a677b8922c94e01bdbb12126b0bc852f00447528dee1782229af9c720c3f348" +checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be" dependencies = [ "cfg-if", "cpufeatures", "curve25519-dalek-derive", "digest 0.10.7", "fiat-crypto", - "platforms", "rustc_version", "subtle", "zeroize", @@ -978,14 +976,14 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] name = "darling" -version = "0.20.9" +version = "0.20.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83b2eb4d90d12bdda5ed17de686c2acb4c57914f8f921b8da7e112b5a36f3fe1" +checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989" dependencies = [ "darling_core", "darling_macro", @@ -993,27 +991,27 @@ dependencies = [ [[package]] name = "darling_core" -version = "0.20.9" +version = "0.20.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "622687fe0bac72a04e5599029151f5796111b90f1baaa9b544d807a5e31cd120" +checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5" dependencies = [ "fnv", "ident_case", "proc-macro2", "quote", "strsim", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] name = "darling_macro" -version = "0.20.9" +version = "0.20.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178" +checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806" dependencies = [ "darling_core", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -1054,13 +1052,13 @@ dependencies = [ [[package]] name = "derive_more" -version = "0.99.17" +version = "0.99.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321" +checksum = "5f33878137e4dafd7fa914ad4e259e18a4e8e532b9617a2d0150262bf53abfce" dependencies = [ "proc-macro2", "quote", - "syn 1.0.109", + "syn 2.0.71", ] [[package]] @@ -1074,6 +1072,10 @@ dependencies = [ "time", ] +[[package]] +name = "diesel-wasm-sqlite" +version = "0.1.0" + [[package]] name = "diesel_derives" version = "2.2.0" @@ -1083,7 +1085,7 @@ dependencies = [ "dsl_auto_type", "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -1101,7 +1103,7 @@ name = "diesel_table_macro_syntax" version = "0.2.0" source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -1189,7 +1191,7 @@ dependencies = [ "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -1252,9 +1254,9 @@ dependencies = [ [[package]] name = "either" -version = "1.12.0" +version = "1.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b" +checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" [[package]] name = "elliptic-curve" @@ -1515,7 +1517,7 @@ dependencies = [ "reqwest 0.11.27", "serde", "serde_json", - "syn 2.0.66", + "syn 2.0.71", "toml", "walkdir", ] @@ -1533,7 +1535,7 @@ dependencies = [ "proc-macro2", "quote", "serde_json", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -1559,7 +1561,7 @@ dependencies = [ "serde", "serde_json", "strum", - "syn 2.0.66", + "syn 2.0.71", "tempfile", "thiserror", "tiny-keccak", @@ -1944,7 +1946,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -2032,9 +2034,9 @@ dependencies = [ [[package]] name = "gimli" -version = "0.28.1" +version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" +checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd" [[package]] name = "glob" @@ -2319,9 +2321,9 @@ dependencies = [ [[package]] name = "http-body" -version = "1.0.0" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643" +checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184" dependencies = [ "bytes", "http 1.1.0", @@ -2329,22 +2331,22 @@ dependencies = [ [[package]] name = "http-body-util" -version = "0.1.1" +version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0475f8b2ac86659c21b64320d5d653f9efe42acd2a4e560073ec61a155a34f1d" +checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f" dependencies = [ "bytes", - "futures-core", + "futures-util", "http 1.1.0", - "http-body 1.0.0", + "http-body 1.0.1", "pin-project-lite", ] [[package]] name = "httparse" -version = "1.8.0" +version = "1.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904" +checksum = "0fcc0b4a115bf80b728eb8ea024ad5bd707b615bfed49e0665b6e0f86fd082d9" [[package]] name = "httpdate" @@ -2360,9 +2362,9 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" [[package]] name = "hyper" -version = "0.14.28" +version = "0.14.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80" +checksum = "a152ddd61dfaec7273fe8419ab357f33aee0d914c5f4efbf0d96fa749eea5ec9" dependencies = [ "bytes", "futures-channel", @@ -2384,16 +2386,16 @@ dependencies = [ [[package]] name = "hyper" -version = "1.3.1" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe575dd17d0862a9a33781c8c4696a55c320909004a67a00fb286ba8b1bc496d" +checksum = "50dfd22e0e76d0f662d429a5f80fcaf3855009297eab6a0a9f8543834744ba05" dependencies = [ "bytes", "futures-channel", "futures-util", "h2 0.4.5", "http 1.1.0", - "http-body 1.0.0", + "http-body 1.0.1", "httparse", "itoa", "pin-project-lite", @@ -2410,19 +2412,36 @@ checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" dependencies = [ "futures-util", "http 0.2.12", - "hyper 0.14.28", + "hyper 0.14.30", "rustls 0.21.12", "tokio", "tokio-rustls 0.24.1", ] +[[package]] +name = "hyper-rustls" +version = "0.27.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ee4be2c948921a1a5320b629c4193916ed787a7f7f293fd3f7f5a6c9de74155" +dependencies = [ + "futures-util", + "http 1.1.0", + "hyper 1.4.1", + "hyper-util", + "rustls 0.23.11", + "rustls-pki-types", + "tokio", + "tokio-rustls 0.26.0", + "tower-service", +] + [[package]] name = "hyper-timeout" version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbb958482e8c7be4bc3cf272a766a2b0bf1a6755e7a6ae777f017a31d11b13b1" dependencies = [ - "hyper 0.14.28", + "hyper 0.14.30", "pin-project-lite", "tokio", "tokio-io-timeout", @@ -2436,7 +2455,7 @@ checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0" dependencies = [ "bytes", "http-body-util", - "hyper 1.3.1", + "hyper 1.4.1", "hyper-util", "native-tls", "tokio", @@ -2446,16 +2465,16 @@ dependencies = [ [[package]] name = "hyper-util" -version = "0.1.4" +version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d8d52be92d09acc2e01dddb7fde3ad983fc6489c7db4837e605bc3fca4cb63e" +checksum = "3ab92f4f49ee4fb4f997c784b7a2e0fa70050211e0b6a287f898c3c9785ca956" dependencies = [ "bytes", "futures-channel", "futures-util", "http 1.1.0", - "http-body 1.0.0", - "hyper 1.3.1", + "http-body 1.0.1", + "hyper 1.4.1", "pin-project-lite", "socket2", "tokio", @@ -2757,7 +2776,7 @@ dependencies = [ "lalrpop-util", "petgraph", "regex", - "regex-syntax 0.8.3", + "regex-syntax 0.8.4", "string_cache", "term", "tiny-keccak", @@ -2771,14 +2790,14 @@ version = "0.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "507460a910eb7b32ee961886ff48539633b788a36b65692b95f225b844c82553" dependencies = [ - "regex-automata 0.4.6", + "regex-automata 0.4.7", ] [[package]] name = "lazy_static" -version = "1.4.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" [[package]] name = "libc" @@ -2798,7 +2817,7 @@ version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "libc", ] @@ -2880,9 +2899,9 @@ dependencies = [ [[package]] name = "log" -version = "0.4.21" +version = "0.4.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" dependencies = [ "serde", "value-bag", @@ -2915,9 +2934,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.7.2" +version = "2.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "migrations_internals" @@ -2946,9 +2965,9 @@ checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" [[package]] name = "mime_guess" -version = "2.0.4" +version = "2.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef" +checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e" dependencies = [ "mime", "unicase", @@ -2956,9 +2975,9 @@ dependencies = [ [[package]] name = "miniz_oxide" -version = "0.7.3" +version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87dfd01fe195c66b572b37921ad8803d010623c0aca821bea2302239d155cdae" +checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08" dependencies = [ "adler", ] @@ -3039,7 +3058,7 @@ dependencies = [ "assert-json-diff", "colored", "futures-core", - "hyper 0.14.28", + "hyper 0.14.30", "log", "rand", "regex", @@ -3090,11 +3109,10 @@ dependencies = [ [[package]] name = "native-tls" -version = "0.2.11" +version = "0.2.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e" +checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466" dependencies = [ - "lazy_static", "libc", "log", "openssl", @@ -3130,9 +3148,9 @@ dependencies = [ [[package]] name = "num-bigint" -version = "0.4.5" +version = "0.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c165a9ab64cf766f73521c0dd2cfdff64f488b8f0b3e621face3462d3db536d7" +checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9" dependencies = [ "num-integer", "num-traits", @@ -3191,7 +3209,7 @@ dependencies = [ "proc-macro-crate", "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -3202,9 +3220,9 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3" [[package]] name = "object" -version = "0.32.2" +version = "0.36.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441" +checksum = "081b846d1d56ddfc18fdf1a922e4f6e07a11768ea1b92dec44e42b72712ccfce" dependencies = [ "memchr", ] @@ -3217,9 +3235,9 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" [[package]] name = "oorandom" -version = "11.1.3" +version = "11.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575" +checksum = "b410bbe7e14ab526a0e86877eb47c6996a2bd7746f027ba551028c925390e4e9" [[package]] name = "opaque-debug" @@ -3338,7 +3356,7 @@ dependencies = [ "quote", "rstest", "rstest_reuse", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -3356,7 +3374,7 @@ version = "0.10.64" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "cfg-if", "foreign-types", "libc", @@ -3373,7 +3391,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -3384,9 +3402,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" [[package]] name = "openssl-src" -version = "300.3.0+3.3.0" +version = "300.3.1+3.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eba8804a1c5765b18c4b3f907e6897ebabeedebc9830e1a0046c4a4cf44663e1" +checksum = "7259953d42a81bf137fbbd73bd30a8e1914d6dce43c2b90ed575783a22608b91" dependencies = [ "cc", ] @@ -3507,9 +3525,9 @@ checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" dependencies = [ "cfg-if", "libc", - "redox_syscall 0.5.1", + "redox_syscall 0.5.3", "smallvec", - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -3699,7 +3717,7 @@ dependencies = [ "phf_shared 0.11.2", "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -3737,7 +3755,7 @@ checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -3778,12 +3796,6 @@ version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" -[[package]] -name = "platforms" -version = "3.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db23d408679286588f4d4644f965003d056e3dd5abcaaa938116871d7ce2fee7" - [[package]] name = "plotters" version = "0.3.6" @@ -3906,7 +3918,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e" dependencies = [ "proc-macro2", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -3943,26 +3955,26 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.83" +version = "1.0.86" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b33eb56c327dec362a9e55b3ad14f9d2f0904fb5a5b03b513ab5465399e9f43" +checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77" dependencies = [ "unicode-ident", ] [[package]] name = "proptest" -version = "1.4.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31b476131c3c86cb68032fdc5cb6d5a1045e3e42d96b69fa599fd77701e1f5bf" +checksum = "b4c2511913b88df1637da85cc8d96ec8e43a3f8bb8ccb71ee1ac240d6f3df58d" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "lazy_static", "num-traits", "rand", "rand_chacha", "rand_xorshift", - "regex-syntax 0.8.3", + "regex-syntax 0.8.4", "unarray", ] @@ -4025,7 +4037,7 @@ dependencies = [ "prost 0.12.6", "prost-types 0.12.6", "regex", - "syn 2.0.66", + "syn 2.0.71", "tempfile", ] @@ -4052,7 +4064,7 @@ dependencies = [ "itertools 0.12.1", "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -4169,11 +4181,11 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.5.1" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "469052894dcb553421e483e4209ee581a45100d31b4018de03e5a7ad86374a7e" +checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", ] [[package]] @@ -4189,14 +4201,14 @@ dependencies = [ [[package]] name = "regex" -version = "1.10.4" +version = "1.10.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c" +checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f" dependencies = [ "aho-corasick", "memchr", - "regex-automata 0.4.6", - "regex-syntax 0.8.3", + "regex-automata 0.4.7", + "regex-syntax 0.8.4", ] [[package]] @@ -4210,13 +4222,13 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.6" +version = "0.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea" +checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df" dependencies = [ "aho-corasick", "memchr", - "regex-syntax 0.8.3", + "regex-syntax 0.8.4", ] [[package]] @@ -4227,9 +4239,9 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" [[package]] name = "regex-syntax" -version = "0.8.3" +version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56" +checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b" [[package]] name = "reqwest" @@ -4245,8 +4257,8 @@ dependencies = [ "h2 0.3.26", "http 0.2.12", "http-body 0.4.6", - "hyper 0.14.28", - "hyper-rustls", + "hyper 0.14.30", + "hyper-rustls 0.24.2", "ipnet", "js-sys", "log", @@ -4259,7 +4271,7 @@ dependencies = [ "serde", "serde_json", "serde_urlencoded", - "sync_wrapper", + "sync_wrapper 0.1.2", "system-configuration", "tokio", "tokio-rustls 0.24.1", @@ -4274,9 +4286,9 @@ dependencies = [ [[package]] name = "reqwest" -version = "0.12.4" +version = "0.12.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "566cafdd92868e0939d3fb961bd0dc25fcfaaed179291093b3d43e6b3150ea10" +checksum = "c7d6d2a27d57148378eb5e111173f4276ad26340ecc5c49a4a2152167a2d6a37" dependencies = [ "base64 0.22.1", "bytes", @@ -4285,9 +4297,10 @@ dependencies = [ "futures-util", "h2 0.4.5", "http 1.1.0", - "http-body 1.0.0", + "http-body 1.0.1", "http-body-util", - "hyper 1.3.1", + "hyper 1.4.1", + "hyper-rustls 0.27.2", "hyper-tls", "hyper-util", "ipnet", @@ -4302,7 +4315,7 @@ dependencies = [ "serde", "serde_json", "serde_urlencoded", - "sync_wrapper", + "sync_wrapper 1.0.1", "system-configuration", "tokio", "tokio-native-tls", @@ -4463,7 +4476,7 @@ version = "0.38.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "errno", "libc", "linux-raw-sys", @@ -4491,16 +4504,29 @@ dependencies = [ "log", "ring 0.17.8", "rustls-pki-types", - "rustls-webpki 0.102.4", + "rustls-webpki 0.102.5", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls" +version = "0.23.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4828ea528154ae444e5a642dbb7d5623354030dc9822b83fd9bb79683c7399d0" +dependencies = [ + "once_cell", + "rustls-pki-types", + "rustls-webpki 0.102.5", "subtle", "zeroize", ] [[package]] name = "rustls-native-certs" -version = "0.7.0" +version = "0.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f1fb85efa936c42c6d5fc28d2629bb51e4b2f4b8a5211e297d599cc5a093792" +checksum = "a88d6d420651b496bdd98684116959239430022a115c1240e6c3993be0b15fba" dependencies = [ "openssl-probe", "rustls-pemfile 2.1.2", @@ -4556,9 +4582,9 @@ dependencies = [ [[package]] name = "rustls-webpki" -version = "0.102.4" +version = "0.102.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff448f7e92e913c4b7d4c6d8e4540a1724b319b4152b8aef6d4cf8339712b33e" +checksum = "f9a6fccd794a42c2c105b513a2f62bc3fd8f3ba57a4593677ceb0bd035164d78" dependencies = [ "ring 0.17.8", "rustls-pki-types", @@ -4701,11 +4727,11 @@ dependencies = [ [[package]] name = "security-framework" -version = "2.11.0" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c627723fd09706bacdb5cf41499e95098555af3c3c29d014dc3c458ef6be11c0" +checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.6.0", "core-foundation", "core-foundation-sys", "libc", @@ -4714,9 +4740,9 @@ dependencies = [ [[package]] name = "security-framework-sys" -version = "2.11.0" +version = "2.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "317936bbbd05227752583946b9e66d7ce3b489f84e11a94a510b4437fef407d7" +checksum = "75da29fe9b9b08fe9d6b22b5b4bcbc75d8db3aa31e639aa56bb62e9d46bfceaf" dependencies = [ "core-foundation-sys", "libc", @@ -4745,22 +4771,22 @@ checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73" [[package]] name = "serde" -version = "1.0.202" +version = "1.0.204" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "226b61a0d411b2ba5ff6d7f73a476ac4f8bb900373459cd00fab8512828ba395" +checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.202" +version = "1.0.204" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6048858004bcff69094cd972ed40a32500f153bd3be9f716b2eed2e8217c4838" +checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -4774,9 +4800,9 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.117" +version = "1.0.120" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3" +checksum = "4e0d21c9a8cae1235ad58a00c11cb40d4b1e5c784f1ef2c537876ed6ffd8b7c5" dependencies = [ "itoa", "ryu", @@ -4924,7 +4950,7 @@ checksum = "0eb01866308440fc64d6c44d9e86c5cc17adfe33c4d6eed55da9145044d0ffc1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -5013,31 +5039,31 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" [[package]] name = "strum" -version = "0.26.2" +version = "0.26.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d8cec3501a5194c432b2b7976db6b7d10ec95c253208b45f83f7136aa985e29" +checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06" dependencies = [ "strum_macros", ] [[package]] name = "strum_macros" -version = "0.26.2" +version = "0.26.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6cf59daf282c0a494ba14fd21610a0325f9f90ec9d1231dea26bcb1d696c946" +checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be" dependencies = [ - "heck 0.4.1", + "heck 0.5.0", "proc-macro2", "quote", "rustversion", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] name = "subtle" -version = "2.5.0" +version = "2.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" [[package]] name = "sval" @@ -5150,9 +5176,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.66" +version = "2.0.71" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c42f3f41a2de00b01c0aaad383c5a45241efc8b2d1eda5661812fda5f3cdcff5" +checksum = "b146dcf730474b4bcd16c311627b31ede9ab149045db4d6088b3becaea046462" dependencies = [ "proc-macro2", "quote", @@ -5165,6 +5191,12 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" +[[package]] +name = "sync_wrapper" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394" + [[package]] name = "system-configuration" version = "0.5.1" @@ -5232,22 +5264,22 @@ checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76" [[package]] name = "thiserror" -version = "1.0.61" +version = "1.0.63" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709" +checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.61" +version = "1.0.63" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533" +checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -5322,9 +5354,9 @@ dependencies = [ [[package]] name = "tinyvec" -version = "1.6.0" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" +checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938" dependencies = [ "tinyvec_macros", ] @@ -5349,7 +5381,7 @@ dependencies = [ [[package]] name = "tls_codec" version = "0.4.2-pre.1" -source = "git+https://github.com/rustcrypto/formats#6c42217ec681a073bfbdfffd78588306f9063de2" +source = "git+https://github.com/rustcrypto/formats#d32a61ea61d44152ce17380964d233b439ce603a" dependencies = [ "serde", "tls_codec_derive 0.4.1 (git+https://github.com/rustcrypto/formats)", @@ -5364,24 +5396,24 @@ checksum = "8d9ef545650e79f30233c0003bcc2504d7efac6dad25fca40744de773fe2049c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] name = "tls_codec_derive" version = "0.4.1" -source = "git+https://github.com/rustcrypto/formats#6c42217ec681a073bfbdfffd78588306f9063de2" +source = "git+https://github.com/rustcrypto/formats#d32a61ea61d44152ce17380964d233b439ce603a" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] name = "tokio" -version = "1.37.0" +version = "1.38.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787" +checksum = "eb2caba9f80616f438e09748d5acda951967e1ea58508ef53d9c6402485a46df" dependencies = [ "backtrace", "bytes", @@ -5408,13 +5440,13 @@ dependencies = [ [[package]] name = "tokio-macros" -version = "2.2.0" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b" +checksum = "5f5ae998a069d4b5aba8ee9dad856af7d520c3699e6159b185c2acd48155d39a" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -5448,6 +5480,17 @@ dependencies = [ "tokio", ] +[[package]] +name = "tokio-rustls" +version = "0.26.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4" +dependencies = [ + "rustls 0.23.11", + "rustls-pki-types", + "tokio", +] + [[package]] name = "tokio-stream" version = "0.1.15" @@ -5502,14 +5545,14 @@ dependencies = [ [[package]] name = "toml" -version = "0.8.13" +version = "0.8.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4e43f8cc456c9704c851ae29c67e17ef65d2c30017c17a9765b89c382dc8bba" +checksum = "ac2caab0bf757388c6c0ae23b3293fdb463fee59434529014f85e3263b995c28" dependencies = [ "serde", "serde_spanned", "toml_datetime", - "toml_edit 0.22.13", + "toml_edit 0.22.16", ] [[package]] @@ -5534,15 +5577,15 @@ dependencies = [ [[package]] name = "toml_edit" -version = "0.22.13" +version = "0.22.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c127785850e8c20836d49732ae6abfa47616e60bf9d9f57c43c250361a9db96c" +checksum = "278f3d518e152219c994ce877758516bca5e118eaed6996192a774fb9fbf0788" dependencies = [ "indexmap 2.2.6", "serde", "serde_spanned", "toml_datetime", - "winnow 0.6.8", + "winnow 0.6.13", ] [[package]] @@ -5559,7 +5602,7 @@ dependencies = [ "h2 0.3.26", "http 0.2.12", "http-body 0.4.6", - "hyper 0.14.28", + "hyper 0.14.30", "hyper-timeout", "percent-encoding", "pin-project", @@ -5574,7 +5617,7 @@ dependencies = [ "tower-layer", "tower-service", "tracing", - "webpki-roots 0.26.1", + "webpki-roots 0.26.3", ] [[package]] @@ -5629,7 +5672,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -5694,11 +5737,10 @@ dependencies = [ [[package]] name = "tracing-test" -version = "0.2.4" +version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3a2c0ff408fe918a94c428a3f2ad04e4afd5c95bbc08fcf868eff750c15728a4" +checksum = "557b891436fe0d5e0e363427fc7f217abf9ccd510d5136549847bdcbcd011d68" dependencies = [ - "lazy_static", "tracing-core", "tracing-subscriber", "tracing-test-macro", @@ -5706,13 +5748,12 @@ dependencies = [ [[package]] name = "tracing-test-macro" -version = "0.2.4" +version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "258bc1c4f8e2e73a977812ab339d503e6feeb92700f6d07a6de4d321522d5c08" +checksum = "04659ddb06c87d233c566112c1c9c5b9e98256d9af50ec3bc9c8327f873a7568" dependencies = [ - "lazy_static", "quote", - "syn 1.0.109", + "syn 2.0.71", ] [[package]] @@ -5822,9 +5863,9 @@ dependencies = [ [[package]] name = "unicode-width" -version = "0.1.12" +version = "0.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68f5e5f3158ecfd4b8ff6fe086db7c8467a2dfdac97fe420f2b7c4aa97af66d6" +checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d" [[package]] name = "unicode-xid" @@ -5856,9 +5897,9 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" [[package]] name = "url" -version = "2.5.0" +version = "2.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633" +checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c" dependencies = [ "form_urlencoded", "idna", @@ -5873,9 +5914,9 @@ checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" [[package]] name = "utf8parse" -version = "0.2.1" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" [[package]] name = "uuid" @@ -5889,9 +5930,9 @@ dependencies = [ [[package]] name = "uuid" -version = "1.8.0" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0" +checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314" dependencies = [ "getrandom", ] @@ -5980,7 +6021,7 @@ dependencies = [ "futures-util", "headers", "http 0.2.12", - "hyper 0.14.28", + "hyper 0.14.30", "log", "mime", "mime_guess", @@ -6027,7 +6068,7 @@ dependencies = [ "once_cell", "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", "wasm-bindgen-shared", ] @@ -6061,7 +6102,7 @@ checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -6094,7 +6135,7 @@ checksum = "b7f89739351a2e03cb94beb799d47fb2cac01759b40ec441f7de39b00cbf7ef0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -6137,9 +6178,9 @@ checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1" [[package]] name = "webpki-roots" -version = "0.26.1" +version = "0.26.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3de34ae270483955a94f4b21bdaaeb83d508bb84a01435f393818edb0012009" +checksum = "bd7c23921eeb1713a4e851530e9b9756e4fb0e89978582942612524cf09f01cd" dependencies = [ "rustls-pki-types", ] @@ -6193,7 +6234,7 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" dependencies = [ - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -6211,7 +6252,7 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" dependencies = [ - "windows-targets 0.52.5", + "windows-targets 0.52.6", ] [[package]] @@ -6231,18 +6272,18 @@ dependencies = [ [[package]] name = "windows-targets" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" dependencies = [ - "windows_aarch64_gnullvm 0.52.5", - "windows_aarch64_msvc 0.52.5", - "windows_i686_gnu 0.52.5", + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", "windows_i686_gnullvm", - "windows_i686_msvc 0.52.5", - "windows_x86_64_gnu 0.52.5", - "windows_x86_64_gnullvm 0.52.5", - "windows_x86_64_msvc 0.52.5", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", ] [[package]] @@ -6253,9 +6294,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" [[package]] name = "windows_aarch64_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" [[package]] name = "windows_aarch64_msvc" @@ -6265,9 +6306,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" [[package]] name = "windows_aarch64_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" [[package]] name = "windows_i686_gnu" @@ -6277,15 +6318,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" [[package]] name = "windows_i686_gnu" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" [[package]] name = "windows_i686_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" [[package]] name = "windows_i686_msvc" @@ -6295,9 +6336,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" [[package]] name = "windows_i686_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" [[package]] name = "windows_x86_64_gnu" @@ -6307,9 +6348,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" [[package]] name = "windows_x86_64_gnu" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" [[package]] name = "windows_x86_64_gnullvm" @@ -6319,9 +6360,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" [[package]] name = "windows_x86_64_gnullvm" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" [[package]] name = "windows_x86_64_msvc" @@ -6331,9 +6372,9 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" [[package]] name = "windows_x86_64_msvc" -version = "0.52.5" +version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" [[package]] name = "winnow" @@ -6346,9 +6387,9 @@ dependencies = [ [[package]] name = "winnow" -version = "0.6.8" +version = "0.6.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3c52e9c97a68071b23e836c9380edae937f17b9c4667bd021973efc689f618d" +checksum = "59b5e5f6c299a3c7890b876a2a587f3115162487e704907d9b6cd29473052ba1" dependencies = [ "memchr", ] @@ -6422,7 +6463,7 @@ dependencies = [ "futures", "hex", "http-body 0.4.6", - "hyper 0.14.28", + "hyper 0.14.30", "log", "pbjson 0.5.1", "pbjson-types 0.5.1", @@ -6432,7 +6473,7 @@ dependencies = [ "tonic", "tower", "tracing", - "uuid 1.8.0", + "uuid 1.10.0", "webpki-roots 0.23.1", "xmtp_proto", "xmtp_v2", @@ -6550,7 +6591,7 @@ dependencies = [ "openmls_traits", "prost 0.12.6", "rand", - "reqwest 0.12.4", + "reqwest 0.12.5", "ring 0.17.8", "serde", "serde_json", @@ -6630,9 +6671,9 @@ checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec" [[package]] name = "zeroize" -version = "1.7.0" +version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d" +checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" dependencies = [ "zeroize_derive", ] @@ -6645,7 +6686,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ "proc-macro2", "quote", - "syn 2.0.66", + "syn 2.0.71", ] [[package]] @@ -6689,9 +6730,9 @@ dependencies = [ [[package]] name = "zstd-sys" -version = "2.0.10+zstd.1.5.6" +version = "2.0.12+zstd.1.5.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c253a4914af5bafc8fa8c86ee400827e83cf6ec01195ec1f1ed8441bf00d65aa" +checksum = "0a4e40c320c3cb459d9a9ff6de98cff88f4751ee9275d140e2be94a2b74e4c13" dependencies = [ "cc", "pkg-config", diff --git a/Cargo.toml b/Cargo.toml index bd80ea6a7..1fc4ec3c6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,7 +9,7 @@ members = [ "xmtp_user_preferences", "xmtp_v2", "xmtp_mls", - "xmtp_id", + "xmtp_id", "diesel-wasm-sqlite", ] exclude = [ diff --git a/diesel-wasm-sqlite/Cargo.toml b/diesel-wasm-sqlite/Cargo.toml new file mode 100644 index 000000000..28c02a0db --- /dev/null +++ b/diesel-wasm-sqlite/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "diesel-wasm-sqlite" +version = "0.1.0" +edition = "2021" + +[dependencies] diff --git a/diesel-wasm-sqlite/README.md b/diesel-wasm-sqlite/README.md new file mode 100644 index 000000000..d30161ad3 --- /dev/null +++ b/diesel-wasm-sqlite/README.md @@ -0,0 +1 @@ +# Custom Diesel Backend for Wasm wa-sqlite diff --git a/xmtp_mls/src/storage/wasm_sqlite/backend.rs b/diesel-wasm-sqlite/src/backend.rs similarity index 100% rename from xmtp_mls/src/storage/wasm_sqlite/backend.rs rename to diesel-wasm-sqlite/src/backend.rs diff --git a/xmtp_mls/src/storage/wasm_sqlite/connection.rs b/diesel-wasm-sqlite/src/connection.rs similarity index 100% rename from xmtp_mls/src/storage/wasm_sqlite/connection.rs rename to diesel-wasm-sqlite/src/connection.rs diff --git a/xmtp_mls/src/storage/wasm_sqlite/connection/bind_collector.rs b/diesel-wasm-sqlite/src/connection/bind_collector.rs similarity index 100% rename from xmtp_mls/src/storage/wasm_sqlite/connection/bind_collector.rs rename to diesel-wasm-sqlite/src/connection/bind_collector.rs diff --git a/xmtp_mls/src/storage/wasm_sqlite/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs similarity index 100% rename from xmtp_mls/src/storage/wasm_sqlite/ffi.rs rename to diesel-wasm-sqlite/src/ffi.rs diff --git a/diesel-wasm-sqlite/src/lib.rs b/diesel-wasm-sqlite/src/lib.rs new file mode 100644 index 000000000..7d12d9af8 --- /dev/null +++ b/diesel-wasm-sqlite/src/lib.rs @@ -0,0 +1,14 @@ +pub fn add(left: usize, right: usize) -> usize { + left + right +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn it_works() { + let result = add(2, 2); + assert_eq!(result, 4); + } +} diff --git a/xmtp_mls/src/storage/wasm_sqlite/mod.rs b/diesel-wasm-sqlite/src/mod.rs similarity index 100% rename from xmtp_mls/src/storage/wasm_sqlite/mod.rs rename to diesel-wasm-sqlite/src/mod.rs diff --git a/xmtp_mls/src/storage/wasm_sqlite/query_builder/limit_offset.rs b/diesel-wasm-sqlite/src/query_builder/limit_offset.rs similarity index 100% rename from xmtp_mls/src/storage/wasm_sqlite/query_builder/limit_offset.rs rename to diesel-wasm-sqlite/src/query_builder/limit_offset.rs diff --git a/xmtp_mls/src/storage/wasm_sqlite/query_builder/mod.rs b/diesel-wasm-sqlite/src/query_builder/mod.rs similarity index 100% rename from xmtp_mls/src/storage/wasm_sqlite/query_builder/mod.rs rename to diesel-wasm-sqlite/src/query_builder/mod.rs diff --git a/xmtp_mls/src/storage/wasm_sqlite/query_builder/query_fragment_impls.rs b/diesel-wasm-sqlite/src/query_builder/query_fragment_impls.rs similarity index 100% rename from xmtp_mls/src/storage/wasm_sqlite/query_builder/query_fragment_impls.rs rename to diesel-wasm-sqlite/src/query_builder/query_fragment_impls.rs diff --git a/xmtp_mls/src/storage/wasm_sqlite/query_builder/returning.rs b/diesel-wasm-sqlite/src/query_builder/returning.rs similarity index 100% rename from xmtp_mls/src/storage/wasm_sqlite/query_builder/returning.rs rename to diesel-wasm-sqlite/src/query_builder/returning.rs diff --git a/xmtp_mls/src/storage/wasm_sqlite/sqlite_types.rs b/diesel-wasm-sqlite/src/sqlite_types.rs similarity index 100% rename from xmtp_mls/src/storage/wasm_sqlite/sqlite_types.rs rename to diesel-wasm-sqlite/src/sqlite_types.rs diff --git a/xmtp_mls/src/storage/mod.rs b/xmtp_mls/src/storage/mod.rs index e630023c4..82ca3f125 100644 --- a/xmtp_mls/src/storage/mod.rs +++ b/xmtp_mls/src/storage/mod.rs @@ -2,8 +2,6 @@ mod encrypted_store; mod errors; mod serialization; pub mod sql_key_store; -#[cfg(feature = "web")] -pub mod wasm_sqlite; pub use encrypted_store::*; pub use errors::StorageError; From 5981d65c97a340e3904792ad2213964239218908 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Wed, 17 Jul 2024 15:32:44 -0400 Subject: [PATCH 03/28] cleanup + crate --- Cargo.lock | 6 +- diesel-wasm-sqlite/Cargo.toml | 3 + .../src/connection/bind_collector.rs | 12 +-- diesel-wasm-sqlite/src/lib.rs | 86 +++++++++++++++++-- diesel-wasm-sqlite/src/mod.rs | 82 ------------------ .../src/query_builder/limit_offset.rs | 2 +- .../src/query_builder/returning.rs | 2 +- xmtp_mls/Cargo.toml | 5 +- 8 files changed, 94 insertions(+), 104 deletions(-) delete mode 100644 diesel-wasm-sqlite/src/mod.rs diff --git a/Cargo.lock b/Cargo.lock index 127a89a12..fd0c847b4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1075,6 +1075,11 @@ dependencies = [ [[package]] name = "diesel-wasm-sqlite" version = "0.1.0" +dependencies = [ + "diesel", + "log", + "wasm-bindgen", +] [[package]] name = "diesel_derives" @@ -6608,7 +6613,6 @@ dependencies = [ "tracing-log", "tracing-subscriber", "tracing-test", - "wasm-bindgen", "xmtp_api_grpc", "xmtp_cryptography", "xmtp_id", diff --git a/diesel-wasm-sqlite/Cargo.toml b/diesel-wasm-sqlite/Cargo.toml index 28c02a0db..5f68163b6 100644 --- a/diesel-wasm-sqlite/Cargo.toml +++ b/diesel-wasm-sqlite/Cargo.toml @@ -4,3 +4,6 @@ version = "0.1.0" edition = "2021" [dependencies] +diesel = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend", features = ["r2d2", "i-implement-a-third-party-backend-and-opt-into-breaking-changes"] } +wasm-bindgen = "0.2" +log = "0.4" diff --git a/diesel-wasm-sqlite/src/connection/bind_collector.rs b/diesel-wasm-sqlite/src/connection/bind_collector.rs index 68a827d08..377647e03 100644 --- a/diesel-wasm-sqlite/src/connection/bind_collector.rs +++ b/diesel-wasm-sqlite/src/connection/bind_collector.rs @@ -1,4 +1,4 @@ -use crate::storage::wasm_sqlite::{SqliteType, WasmSqlite}; +use crate::{SqliteType, WasmSqlite}; use diesel::query_builder::{BindCollector, MoveableBindCollector}; use diesel::result::QueryResult; use diesel::serialize::{IsNull, Output}; @@ -6,11 +6,11 @@ use diesel::sql_types::HasSqlType; #[derive(Debug, Default)] pub struct SqliteBindCollector<'a> { - pub(in crate::storage::wasm_sqlite) binds: Vec<(InternalSqliteBindValue<'a>, SqliteType)>, + pub(crate) binds: Vec<(InternalSqliteBindValue<'a>, SqliteType)>, } impl SqliteBindCollector<'_> { - pub(in crate::storage::wasm_sqlite) fn new() -> Self { + pub(crate) fn new() -> Self { Self { binds: Vec::new() } } } @@ -21,7 +21,7 @@ impl SqliteBindCollector<'_> { /// It can be constructed via the various `From` implementations #[derive(Debug)] pub struct SqliteBindValue<'a> { - pub(in crate::storage::wasm_sqlite) inner: InternalSqliteBindValue<'a>, + pub(crate) inner: InternalSqliteBindValue<'a>, } impl<'a> From for SqliteBindValue<'a> { @@ -125,8 +125,8 @@ impl std::fmt::Display for InternalSqliteBindValue<'_> { impl InternalSqliteBindValue<'_> { #[allow(unsafe_code)] // ffi function calls - pub(in crate::storage::wasm_sqlite) fn result_of(self, ctx: &mut i32) { - use crate::storage::wasm_sqlite::ffi; + pub(crate) fn result_of(self, ctx: &mut i32) { + use crate::ffi; match self { InternalSqliteBindValue::BorrowedString(s) => { ffi::sqlite3_result_text(*ctx, s.to_string()) diff --git a/diesel-wasm-sqlite/src/lib.rs b/diesel-wasm-sqlite/src/lib.rs index 7d12d9af8..f6033799f 100644 --- a/diesel-wasm-sqlite/src/lib.rs +++ b/diesel-wasm-sqlite/src/lib.rs @@ -1,14 +1,82 @@ -pub fn add(left: usize, right: usize) -> usize { - left + right +//! Module for an SQLite backend accesible from the web. +pub mod backend; +pub mod connection; +pub mod ffi; +pub mod query_builder; +pub mod sqlite_types; + +use diesel::{ + connection::{AnsiTransactionManager, Instrumentation, SimpleConnection, TransactionManager}, + query_builder::{QueryFragment, QueryId}, + result::QueryResult, + Connection, +}; +use wasm_bindgen::JsValue; + +pub use backend::{SqliteType, WasmSqlite}; +pub struct WasmSqliteConnection {} +#[derive(Debug)] +pub struct WasmSqliteError(JsValue); + +impl SimpleConnection for WasmSqliteConnection { + fn batch_execute(&mut self, query: &str) -> diesel::prelude::QueryResult<()> { + ffi::batch_execute(query) + .map_err(WasmSqliteError::from) + .map_err(Into::into) + } +} + +impl diesel::connection::ConnectionSealed for WasmSqliteConnection {} + +impl Connection for WasmSqliteConnection { + type Backend = WasmSqlite; + type TransactionManager = AnsiTransactionManager; + + fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { + ffi::establish(database_url) + .map_err(WasmSqliteError::from) + .map_err(Into::::into)?; + Ok(WasmSqliteConnection {}) + } + + fn execute_returning_count(&mut self, source: &T) -> QueryResult + where + T: QueryFragment + QueryId, + { + todo!() + } + + fn transaction_state( + &mut self, + ) -> &mut >::TransactionStateData { + todo!() + } + + fn instrumentation(&mut self) -> &mut dyn Instrumentation { + todo!() + } + + fn set_instrumentation(&mut self, instrumentation: impl diesel::connection::Instrumentation) { + todo!() + } } -#[cfg(test)] -mod tests { - use super::*; +impl From for diesel::result::Error { + fn from(value: WasmSqliteError) -> diesel::result::Error { + log::error!("NOT IMPLEMENTED, {:?}", value); + diesel::result::Error::NotFound + } +} + +impl From for diesel::result::ConnectionError { + fn from(value: WasmSqliteError) -> diesel::result::ConnectionError { + log::error!("NOT IMPLEMENTED, {:?}", value); + diesel::result::ConnectionError::BadConnection("Not implemented".to_string()) + } +} - #[test] - fn it_works() { - let result = add(2, 2); - assert_eq!(result, 4); +impl From for WasmSqliteError { + fn from(err: JsValue) -> WasmSqliteError { + WasmSqliteError(err) } } diff --git a/diesel-wasm-sqlite/src/mod.rs b/diesel-wasm-sqlite/src/mod.rs deleted file mode 100644 index f6033799f..000000000 --- a/diesel-wasm-sqlite/src/mod.rs +++ /dev/null @@ -1,82 +0,0 @@ -//! Module for an SQLite backend accesible from the web. -pub mod backend; -pub mod connection; -pub mod ffi; -pub mod query_builder; -pub mod sqlite_types; - -use diesel::{ - connection::{AnsiTransactionManager, Instrumentation, SimpleConnection, TransactionManager}, - query_builder::{QueryFragment, QueryId}, - result::QueryResult, - Connection, -}; -use wasm_bindgen::JsValue; - -pub use backend::{SqliteType, WasmSqlite}; -pub struct WasmSqliteConnection {} -#[derive(Debug)] -pub struct WasmSqliteError(JsValue); - -impl SimpleConnection for WasmSqliteConnection { - fn batch_execute(&mut self, query: &str) -> diesel::prelude::QueryResult<()> { - ffi::batch_execute(query) - .map_err(WasmSqliteError::from) - .map_err(Into::into) - } -} - -impl diesel::connection::ConnectionSealed for WasmSqliteConnection {} - -impl Connection for WasmSqliteConnection { - type Backend = WasmSqlite; - type TransactionManager = AnsiTransactionManager; - - fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { - ffi::establish(database_url) - .map_err(WasmSqliteError::from) - .map_err(Into::::into)?; - Ok(WasmSqliteConnection {}) - } - - fn execute_returning_count(&mut self, source: &T) -> QueryResult - where - T: QueryFragment + QueryId, - { - todo!() - } - - fn transaction_state( - &mut self, - ) -> &mut >::TransactionStateData { - todo!() - } - - fn instrumentation(&mut self) -> &mut dyn Instrumentation { - todo!() - } - - fn set_instrumentation(&mut self, instrumentation: impl diesel::connection::Instrumentation) { - todo!() - } -} - -impl From for diesel::result::Error { - fn from(value: WasmSqliteError) -> diesel::result::Error { - log::error!("NOT IMPLEMENTED, {:?}", value); - diesel::result::Error::NotFound - } -} - -impl From for diesel::result::ConnectionError { - fn from(value: WasmSqliteError) -> diesel::result::ConnectionError { - log::error!("NOT IMPLEMENTED, {:?}", value); - diesel::result::ConnectionError::BadConnection("Not implemented".to_string()) - } -} - -impl From for WasmSqliteError { - fn from(err: JsValue) -> WasmSqliteError { - WasmSqliteError(err) - } -} diff --git a/diesel-wasm-sqlite/src/query_builder/limit_offset.rs b/diesel-wasm-sqlite/src/query_builder/limit_offset.rs index 734a933a3..65740b9fd 100644 --- a/diesel-wasm-sqlite/src/query_builder/limit_offset.rs +++ b/diesel-wasm-sqlite/src/query_builder/limit_offset.rs @@ -1,4 +1,4 @@ -use crate::storage::wasm_sqlite::WasmSqlite; +use crate::WasmSqlite; use diesel::query_builder::{AstPass, IntoBoxedClause, QueryFragment}; use diesel::query_builder::{BoxedLimitOffsetClause, LimitOffsetClause}; use diesel::query_builder::{LimitClause, NoLimitClause}; diff --git a/diesel-wasm-sqlite/src/query_builder/returning.rs b/diesel-wasm-sqlite/src/query_builder/returning.rs index fef4c8751..8709c1787 100644 --- a/diesel-wasm-sqlite/src/query_builder/returning.rs +++ b/diesel-wasm-sqlite/src/query_builder/returning.rs @@ -1,4 +1,4 @@ -use crate::storage::wasm_sqlite::backend::{SqliteReturningClause, WasmSqlite}; +use crate::backend::{SqliteReturningClause, WasmSqlite}; // use diesel::backend::Backend; use diesel::query_builder::ReturningClause; use diesel::query_builder::{AstPass, QueryFragment}; diff --git a/xmtp_mls/Cargo.toml b/xmtp_mls/Cargo.toml index 511302d5c..b25eddc58 100644 --- a/xmtp_mls/Cargo.toml +++ b/xmtp_mls/Cargo.toml @@ -14,7 +14,7 @@ grpc = ["xmtp_proto/grpc"] native = ["libsqlite3-sys/bundled-sqlcipher-vendored-openssl", "diesel_migrations/sqlite", "diesel/sqlite", "diesel/returning_clauses_for_sqlite_3_35", "tokio/rt-multi-thread", "tokio/macros"] test-utils = ["xmtp_api_grpc"] bench = ["test-utils", "indicatif", "tracing-subscriber", "anyhow", "tracing-flame", "once_cell"] -web = ["wasm-bindgen", "diesel/i-implement-a-third-party-backend-and-opt-into-breaking-changes", "openmls/js", "tokio/macros"] +web = ["openmls/js", "tokio/macros"] [dependencies] aes = "0.8.4" @@ -56,9 +56,6 @@ xmtp_v2 = { path = "../xmtp_v2" } # Native libsqlite3-sys = { version = "0.28.0", optional = true } -# Web -wasm-bindgen = { version = "0.2", optional = true } - # Test/Bench Utils xmtp_api_grpc = { path = "../xmtp_api_grpc", optional = true } tracing-subscriber = { workspace = true, optional = true } From afca3235fbfadcc8dc0bc6cc2204e49d6788cfb6 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Fri, 19 Jul 2024 13:13:18 -0400 Subject: [PATCH 04/28] try to get wa-sqlite to compile with rust wasm --- Cargo.lock | 18 ++++++++ Cargo.toml | 2 +- bindings_ffi/Cargo.lock | 21 +++------ diesel-wasm-sqlite/Cargo.toml | 8 ++++ diesel-wasm-sqlite/js-to-rust-test/index.js | 46 +++++++++++++++++++ .../js-to-rust-test/package.json | 9 ++++ diesel-wasm-sqlite/js-to-rust-test/yarn.lock | 8 ++++ diesel-wasm-sqlite/src/ffi.rs | 21 +++++++-- diesel-wasm-sqlite/src/lib.rs | 34 ++++++++++++-- .../src/query_builder/returning.rs | 1 - 10 files changed, 143 insertions(+), 25 deletions(-) create mode 100644 diesel-wasm-sqlite/js-to-rust-test/index.js create mode 100644 diesel-wasm-sqlite/js-to-rust-test/package.json create mode 100644 diesel-wasm-sqlite/js-to-rust-test/yarn.lock diff --git a/Cargo.lock b/Cargo.lock index fd0c847b4..025898ae1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1077,8 +1077,11 @@ name = "diesel-wasm-sqlite" version = "0.1.0" dependencies = [ "diesel", + "getrandom", "log", + "rand", "wasm-bindgen", + "wasm-bindgen-test", ] [[package]] @@ -5267,6 +5270,21 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76" +[[package]] +name = "test-wasm" +version = "0.1.0" +dependencies = [ + "chrono", + "diesel", + "diesel-wasm-sqlite", + "getrandom", + "rand", + "serde", + "wasm-bindgen", + "wasm-bindgen-test", + "web-sys", +] + [[package]] name = "thiserror" version = "1.0.63" diff --git a/Cargo.toml b/Cargo.toml index 1fc4ec3c6..262d5f577 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,7 +9,7 @@ members = [ "xmtp_user_preferences", "xmtp_v2", "xmtp_mls", - "xmtp_id", "diesel-wasm-sqlite", + "xmtp_id", "diesel-wasm-sqlite", "examples/test-wasm", ] exclude = [ diff --git a/bindings_ffi/Cargo.lock b/bindings_ffi/Cargo.lock index ac3c0372e..83af96ba0 100644 --- a/bindings_ffi/Cargo.lock +++ b/bindings_ffi/Cargo.lock @@ -978,8 +978,7 @@ dependencies = [ [[package]] name = "diesel" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35b696af9ff4c0d2a507db2c5faafa8aa0205e297e5f11e203a24226d5355e7a" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "diesel_derives", "libsqlite3-sys", @@ -990,8 +989,7 @@ dependencies = [ [[package]] name = "diesel_derives" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d6fdd83d5947068817016e939596d246e5367279453f2a3433287894f2f2996" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "diesel_table_macro_syntax", "dsl_auto_type", @@ -1003,8 +1001,7 @@ dependencies = [ [[package]] name = "diesel_migrations" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a73ce704bad4231f001bff3314d91dce4aba0770cee8b233991859abc15c1f6" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "diesel", "migrations_internals", @@ -1014,8 +1011,7 @@ dependencies = [ [[package]] name = "diesel_table_macro_syntax" version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "syn 2.0.48", ] @@ -1083,8 +1079,7 @@ dependencies = [ [[package]] name = "dsl_auto_type" version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab32c18ea6760d951659768a3e35ea72fc1ba0916d665a88dfe048b2a41e543f" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "darling", "either", @@ -2607,8 +2602,7 @@ checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149" [[package]] name = "migrations_internals" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd01039851e82f8799046eabbb354056283fb265c8ec0996af940f4e85a380ff" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "serde", "toml 0.8.8", @@ -2617,8 +2611,7 @@ dependencies = [ [[package]] name = "migrations_macros" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ffb161cc72176cb37aa47f1fc520d3ef02263d67d661f44f05d05a079e1237fd" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "migrations_internals", "proc-macro2", diff --git a/diesel-wasm-sqlite/Cargo.toml b/diesel-wasm-sqlite/Cargo.toml index 5f68163b6..c8fba4f7f 100644 --- a/diesel-wasm-sqlite/Cargo.toml +++ b/diesel-wasm-sqlite/Cargo.toml @@ -7,3 +7,11 @@ edition = "2021" diesel = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend", features = ["r2d2", "i-implement-a-third-party-backend-and-opt-into-breaking-changes"] } wasm-bindgen = "0.2" log = "0.4" + +[dev-dependencies] +rand = "0.8" +getrandom = { version = "0.2", features = ["js"] } +wasm-bindgen-test = "0.3" + +[lib] +crate-type = ["cdylib", "rlib"] diff --git a/diesel-wasm-sqlite/js-to-rust-test/index.js b/diesel-wasm-sqlite/js-to-rust-test/index.js new file mode 100644 index 000000000..fa23e127f --- /dev/null +++ b/diesel-wasm-sqlite/js-to-rust-test/index.js @@ -0,0 +1,46 @@ +import * as SQLite from "@xmtp/wa-sqlite"; +import initModule from "@xmtp/wa-sqlite/build"; + +const sqlite3 = SQLite.Factory(module); + +export function sqlite3_result_text(context, value) { + sqlite3.result_text(context, value); +} + +export function sqlite3_result_int(context, value) { + sqlite3.result_int(context, value); +} + +export function sqlite3_result_int64(context, value) { + sqlite3.result_int64(context, value); +} + +export function sqlite3_result_double(context, value) { + sqlite3.result_double(context, value); +} + +export function sqlite3_result_blob(context, value) { + sqlite3.result_blob(context, value); +} + +export function sqlite3_result_null(context) { + sqlite3.result_null(context); +} + +export function establish(database_url) { + try { + console.log("Opening database!"); + return sqlite3.open_v2(database_url); + } catch { + console.log("establish err"); + } +} + +export function batch_execute(database, query) { + try { + sqlite3.exec(database, query); + console.log("Batch exec'ed"); + } catch { + console.log("exec err"); + } +} diff --git a/diesel-wasm-sqlite/js-to-rust-test/package.json b/diesel-wasm-sqlite/js-to-rust-test/package.json new file mode 100644 index 000000000..3b5389021 --- /dev/null +++ b/diesel-wasm-sqlite/js-to-rust-test/package.json @@ -0,0 +1,9 @@ +{ + "name": "js-to-rust-test", + "version": "1.0.0", + "main": "index.js", + "license": "MIT", + "dependencies": { + "@xmtp/wa-sqlite": "^1.0.1", + } +} diff --git a/diesel-wasm-sqlite/js-to-rust-test/yarn.lock b/diesel-wasm-sqlite/js-to-rust-test/yarn.lock new file mode 100644 index 000000000..a9e0b5b70 --- /dev/null +++ b/diesel-wasm-sqlite/js-to-rust-test/yarn.lock @@ -0,0 +1,8 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@xmtp/wa-sqlite@^1.0.1": + version "1.0.1" + resolved "https://registry.yarnpkg.com/@xmtp/wa-sqlite/-/wa-sqlite-1.0.1.tgz#3ecab8cf3ea15386e3e1d152526d6190898f7529" + integrity sha512-/MVsgo5HG7FVdMMNUKsf5HTIDnOncSK0ljrOBr+xqkfH6qonQwqmUsjcW2Z4GyyCIVvhQlxOSy+1W+7Z/WH0DA== diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index 1f4be65be..aa164a9cb 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -1,22 +1,33 @@ use wasm_bindgen::{prelude::*, JsValue}; /// Simple Connection -#[wasm_bindgen] +#[wasm_bindgen(module = "/js-to-rust-test/index.js")] extern "C" { #[wasm_bindgen(catch)] - pub fn batch_execute(query: &str) -> Result<(), JsValue>; + pub fn batch_execute(database: i32, query: &str) -> Result<(), JsValue>; #[wasm_bindgen(catch)] - pub fn establish(database_url: &str) -> Result<(), JsValue>; + pub fn establish(database_url: &str) -> Result; } -/// Direct Shim for was-sqlite -#[wasm_bindgen] +/// Direct Shim for wa-sqlite +#[wasm_bindgen(module = "/js-to-rust-test/index.js")] extern "C" { + #[wasm_bindgen] pub fn sqlite3_result_text(context: i32, value: String); + + #[wasm_bindgen] pub fn sqlite3_result_int(context: i32, value: i32); + + #[wasm_bindgen] pub fn sqlite3_result_int64(context: i32, value: i64); + + #[wasm_bindgen] pub fn sqlite3_result_double(context: i32, value: f64); + + #[wasm_bindgen] pub fn sqlite3_result_blob(context: i32, value: Vec); + + #[wasm_bindgen] pub fn sqlite3_result_null(context: i32); } diff --git a/diesel-wasm-sqlite/src/lib.rs b/diesel-wasm-sqlite/src/lib.rs index f6033799f..0d3f07afe 100644 --- a/diesel-wasm-sqlite/src/lib.rs +++ b/diesel-wasm-sqlite/src/lib.rs @@ -14,13 +14,18 @@ use diesel::{ use wasm_bindgen::JsValue; pub use backend::{SqliteType, WasmSqlite}; -pub struct WasmSqliteConnection {} + +#[derive(Debug)] +pub struct WasmSqliteConnection { + raw_db_pointer: i32, +} + #[derive(Debug)] pub struct WasmSqliteError(JsValue); impl SimpleConnection for WasmSqliteConnection { fn batch_execute(&mut self, query: &str) -> diesel::prelude::QueryResult<()> { - ffi::batch_execute(query) + ffi::batch_execute(self.raw_db_pointer, query) .map_err(WasmSqliteError::from) .map_err(Into::into) } @@ -33,10 +38,12 @@ impl Connection for WasmSqliteConnection { type TransactionManager = AnsiTransactionManager; fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { - ffi::establish(database_url) + let raw_conn = ffi::establish(database_url) .map_err(WasmSqliteError::from) .map_err(Into::::into)?; - Ok(WasmSqliteConnection {}) + Ok(WasmSqliteConnection { + raw_db_pointer: raw_conn, + }) } fn execute_returning_count(&mut self, source: &T) -> QueryResult @@ -80,3 +87,22 @@ impl From for WasmSqliteError { WasmSqliteError(err) } } + +#[cfg(test)] +mod test { + use super::*; + use wasm_bindgen_test::wasm_bindgen_test; + wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser); + + #[wasm_bindgen_test] + fn test_establish() { + let rng: u16 = rand::random(); + let url = format!( + "{}/wasmtest-{}.db3", + std::env::temp_dir().to_str().unwrap(), + rng + ); + let mut conn = WasmSqliteConnection::establish(&url).unwrap(); + println!("{:?}", conn); + } +} diff --git a/diesel-wasm-sqlite/src/query_builder/returning.rs b/diesel-wasm-sqlite/src/query_builder/returning.rs index 8709c1787..edc466034 100644 --- a/diesel-wasm-sqlite/src/query_builder/returning.rs +++ b/diesel-wasm-sqlite/src/query_builder/returning.rs @@ -1,5 +1,4 @@ use crate::backend::{SqliteReturningClause, WasmSqlite}; -// use diesel::backend::Backend; use diesel::query_builder::ReturningClause; use diesel::query_builder::{AstPass, QueryFragment}; use diesel::result::QueryResult; From 655d8f79c6a21d4b3bb013c5fa1af73ac99585da Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Fri, 19 Jul 2024 14:58:06 -0400 Subject: [PATCH 05/28] try using esbuild --- diesel-wasm-sqlite/esbuild.js | 9 + .../js-to-rust-test/package.json | 9 - diesel-wasm-sqlite/js-to-rust-test/yarn.lock | 8 - diesel-wasm-sqlite/package-lock.json | 420 ++++++++++++++++++ .../{js-to-rust-test/index.js => package.js} | 0 diesel-wasm-sqlite/package.json | 16 + diesel-wasm-sqlite/src/ffi.rs | 4 +- diesel-wasm-sqlite/src/package.js | 2 + 8 files changed, 449 insertions(+), 19 deletions(-) create mode 100644 diesel-wasm-sqlite/esbuild.js delete mode 100644 diesel-wasm-sqlite/js-to-rust-test/package.json delete mode 100644 diesel-wasm-sqlite/js-to-rust-test/yarn.lock create mode 100644 diesel-wasm-sqlite/package-lock.json rename diesel-wasm-sqlite/{js-to-rust-test/index.js => package.js} (100%) create mode 100644 diesel-wasm-sqlite/package.json create mode 100644 diesel-wasm-sqlite/src/package.js diff --git a/diesel-wasm-sqlite/esbuild.js b/diesel-wasm-sqlite/esbuild.js new file mode 100644 index 000000000..00164c0c4 --- /dev/null +++ b/diesel-wasm-sqlite/esbuild.js @@ -0,0 +1,9 @@ +const esbuild = require("esbuild"); + +esbuild.build({ + entryPoints: ["package.js"], + bundle: true, + outfile: "src/package.js", + format: "esm", + minify: true, +}).catch(() => process.exit(1)); diff --git a/diesel-wasm-sqlite/js-to-rust-test/package.json b/diesel-wasm-sqlite/js-to-rust-test/package.json deleted file mode 100644 index 3b5389021..000000000 --- a/diesel-wasm-sqlite/js-to-rust-test/package.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "name": "js-to-rust-test", - "version": "1.0.0", - "main": "index.js", - "license": "MIT", - "dependencies": { - "@xmtp/wa-sqlite": "^1.0.1", - } -} diff --git a/diesel-wasm-sqlite/js-to-rust-test/yarn.lock b/diesel-wasm-sqlite/js-to-rust-test/yarn.lock deleted file mode 100644 index a9e0b5b70..000000000 --- a/diesel-wasm-sqlite/js-to-rust-test/yarn.lock +++ /dev/null @@ -1,8 +0,0 @@ -# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. -# yarn lockfile v1 - - -"@xmtp/wa-sqlite@^1.0.1": - version "1.0.1" - resolved "https://registry.yarnpkg.com/@xmtp/wa-sqlite/-/wa-sqlite-1.0.1.tgz#3ecab8cf3ea15386e3e1d152526d6190898f7529" - integrity sha512-/MVsgo5HG7FVdMMNUKsf5HTIDnOncSK0ljrOBr+xqkfH6qonQwqmUsjcW2Z4GyyCIVvhQlxOSy+1W+7Z/WH0DA== diff --git a/diesel-wasm-sqlite/package-lock.json b/diesel-wasm-sqlite/package-lock.json new file mode 100644 index 000000000..ab3a8e219 --- /dev/null +++ b/diesel-wasm-sqlite/package-lock.json @@ -0,0 +1,420 @@ +{ + "name": "diesel-wasm-sqlite", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "diesel-wasm-sqlite", + "version": "1.0.0", + "license": "ISC", + "dependencies": { + "@xmtp/wa-sqlite": "^1.0.1", + "esbuild": "^0.23.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.23.0.tgz", + "integrity": "sha512-3sG8Zwa5fMcA9bgqB8AfWPQ+HFke6uD3h1s3RIwUNK8EG7a4buxvuFTs3j1IMs2NXAk9F30C/FF4vxRgQCcmoQ==", + "cpu": [ + "ppc64" + ], + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.23.0.tgz", + "integrity": "sha512-+KuOHTKKyIKgEEqKbGTK8W7mPp+hKinbMBeEnNzjJGyFcWsfrXjSTNluJHCY1RqhxFurdD8uNXQDei7qDlR6+g==", + "cpu": [ + "arm" + ], + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.23.0.tgz", + "integrity": "sha512-EuHFUYkAVfU4qBdyivULuu03FhJO4IJN9PGuABGrFy4vUuzk91P2d+npxHcFdpUnfYKy0PuV+n6bKIpHOB3prQ==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.23.0.tgz", + "integrity": "sha512-WRrmKidLoKDl56LsbBMhzTTBxrsVwTKdNbKDalbEZr0tcsBgCLbEtoNthOW6PX942YiYq8HzEnb4yWQMLQuipQ==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.23.0.tgz", + "integrity": "sha512-YLntie/IdS31H54Ogdn+v50NuoWF5BDkEUFpiOChVa9UnKpftgwzZRrI4J132ETIi+D8n6xh9IviFV3eXdxfow==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.23.0.tgz", + "integrity": "sha512-IMQ6eme4AfznElesHUPDZ+teuGwoRmVuuixu7sv92ZkdQcPbsNHzutd+rAfaBKo8YK3IrBEi9SLLKWJdEvJniQ==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.23.0.tgz", + "integrity": "sha512-0muYWCng5vqaxobq6LB3YNtevDFSAZGlgtLoAc81PjUfiFz36n4KMpwhtAd4he8ToSI3TGyuhyx5xmiWNYZFyw==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.23.0.tgz", + "integrity": "sha512-XKDVu8IsD0/q3foBzsXGt/KjD/yTKBCIwOHE1XwiXmrRwrX6Hbnd5Eqn/WvDekddK21tfszBSrE/WMaZh+1buQ==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.23.0.tgz", + "integrity": "sha512-SEELSTEtOFu5LPykzA395Mc+54RMg1EUgXP+iw2SJ72+ooMwVsgfuwXo5Fn0wXNgWZsTVHwY2cg4Vi/bOD88qw==", + "cpu": [ + "arm" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.23.0.tgz", + "integrity": "sha512-j1t5iG8jE7BhonbsEg5d9qOYcVZv/Rv6tghaXM/Ug9xahM0nX/H2gfu6X6z11QRTMT6+aywOMA8TDkhPo8aCGw==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.23.0.tgz", + "integrity": "sha512-P7O5Tkh2NbgIm2R6x1zGJJsnacDzTFcRWZyTTMgFdVit6E98LTxO+v8LCCLWRvPrjdzXHx9FEOA8oAZPyApWUA==", + "cpu": [ + "ia32" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.23.0.tgz", + "integrity": "sha512-InQwepswq6urikQiIC/kkx412fqUZudBO4SYKu0N+tGhXRWUqAx+Q+341tFV6QdBifpjYgUndV1hhMq3WeJi7A==", + "cpu": [ + "loong64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.23.0.tgz", + "integrity": "sha512-J9rflLtqdYrxHv2FqXE2i1ELgNjT+JFURt/uDMoPQLcjWQA5wDKgQA4t/dTqGa88ZVECKaD0TctwsUfHbVoi4w==", + "cpu": [ + "mips64el" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.23.0.tgz", + "integrity": "sha512-cShCXtEOVc5GxU0fM+dsFD10qZ5UpcQ8AM22bYj0u/yaAykWnqXJDpd77ublcX6vdDsWLuweeuSNZk4yUxZwtw==", + "cpu": [ + "ppc64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.23.0.tgz", + "integrity": "sha512-HEtaN7Y5UB4tZPeQmgz/UhzoEyYftbMXrBCUjINGjh3uil+rB/QzzpMshz3cNUxqXN7Vr93zzVtpIDL99t9aRw==", + "cpu": [ + "riscv64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.23.0.tgz", + "integrity": "sha512-WDi3+NVAuyjg/Wxi+o5KPqRbZY0QhI9TjrEEm+8dmpY9Xir8+HE/HNx2JoLckhKbFopW0RdO2D72w8trZOV+Wg==", + "cpu": [ + "s390x" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.23.0.tgz", + "integrity": "sha512-a3pMQhUEJkITgAw6e0bWA+F+vFtCciMjW/LPtoj99MhVt+Mfb6bbL9hu2wmTZgNd994qTAEw+U/r6k3qHWWaOQ==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.23.0.tgz", + "integrity": "sha512-cRK+YDem7lFTs2Q5nEv/HHc4LnrfBCbH5+JHu6wm2eP+d8OZNoSMYgPZJq78vqQ9g+9+nMuIsAO7skzphRXHyw==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.23.0.tgz", + "integrity": "sha512-suXjq53gERueVWu0OKxzWqk7NxiUWSUlrxoZK7usiF50C6ipColGR5qie2496iKGYNLhDZkPxBI3erbnYkU0rQ==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.23.0.tgz", + "integrity": "sha512-6p3nHpby0DM/v15IFKMjAaayFhqnXV52aEmv1whZHX56pdkK+MEaLoQWj+H42ssFarP1PcomVhbsR4pkz09qBg==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.23.0.tgz", + "integrity": "sha512-BFelBGfrBwk6LVrmFzCq1u1dZbG4zy/Kp93w2+y83Q5UGYF1d8sCzeLI9NXjKyujjBBniQa8R8PzLFAUrSM9OA==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.23.0.tgz", + "integrity": "sha512-lY6AC8p4Cnb7xYHuIxQ6iYPe6MfO2CC43XXKo9nBXDb35krYt7KGhQnOkRGar5psxYkircpCqfbNDB4uJbS2jQ==", + "cpu": [ + "arm64" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.23.0.tgz", + "integrity": "sha512-7L1bHlOTcO4ByvI7OXVI5pNN6HSu6pUQq9yodga8izeuB1KcT2UkHaH6118QJwopExPn0rMHIseCTx1CRo/uNA==", + "cpu": [ + "ia32" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.23.0.tgz", + "integrity": "sha512-Arm+WgUFLUATuoxCJcahGuk6Yj9Pzxd6l11Zb/2aAuv5kWWvvfhLFo2fni4uSK5vzlUdCGZ/BdV5tH8klj8p8g==", + "cpu": [ + "x64" + ], + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@xmtp/wa-sqlite": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@xmtp/wa-sqlite/-/wa-sqlite-1.0.1.tgz", + "integrity": "sha512-/MVsgo5HG7FVdMMNUKsf5HTIDnOncSK0ljrOBr+xqkfH6qonQwqmUsjcW2Z4GyyCIVvhQlxOSy+1W+7Z/WH0DA==" + }, + "node_modules/esbuild": { + "version": "0.23.0", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.23.0.tgz", + "integrity": "sha512-1lvV17H2bMYda/WaFb2jLPeHU3zml2k4/yagNMG8Q/YtfMjCwEUZa2eXXMgZTVSL5q1n4H7sQ0X6CdJDqqeCFA==", + "hasInstallScript": true, + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.23.0", + "@esbuild/android-arm": "0.23.0", + "@esbuild/android-arm64": "0.23.0", + "@esbuild/android-x64": "0.23.0", + "@esbuild/darwin-arm64": "0.23.0", + "@esbuild/darwin-x64": "0.23.0", + "@esbuild/freebsd-arm64": "0.23.0", + "@esbuild/freebsd-x64": "0.23.0", + "@esbuild/linux-arm": "0.23.0", + "@esbuild/linux-arm64": "0.23.0", + "@esbuild/linux-ia32": "0.23.0", + "@esbuild/linux-loong64": "0.23.0", + "@esbuild/linux-mips64el": "0.23.0", + "@esbuild/linux-ppc64": "0.23.0", + "@esbuild/linux-riscv64": "0.23.0", + "@esbuild/linux-s390x": "0.23.0", + "@esbuild/linux-x64": "0.23.0", + "@esbuild/netbsd-x64": "0.23.0", + "@esbuild/openbsd-arm64": "0.23.0", + "@esbuild/openbsd-x64": "0.23.0", + "@esbuild/sunos-x64": "0.23.0", + "@esbuild/win32-arm64": "0.23.0", + "@esbuild/win32-ia32": "0.23.0", + "@esbuild/win32-x64": "0.23.0" + } + } + } +} diff --git a/diesel-wasm-sqlite/js-to-rust-test/index.js b/diesel-wasm-sqlite/package.js similarity index 100% rename from diesel-wasm-sqlite/js-to-rust-test/index.js rename to diesel-wasm-sqlite/package.js diff --git a/diesel-wasm-sqlite/package.json b/diesel-wasm-sqlite/package.json new file mode 100644 index 000000000..9709463a6 --- /dev/null +++ b/diesel-wasm-sqlite/package.json @@ -0,0 +1,16 @@ +{ + "name": "diesel-wasm-sqlite", + "version": "1.0.0", + "description": "", + "main": "esbuild.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1", + "esbuild": "node esbuild.js" + }, + "author": "", + "license": "ISC", + "dependencies": { + "@xmtp/wa-sqlite": "^1.0.1", + "esbuild": "^0.23.0" + } +} diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index aa164a9cb..d6db1dad1 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -1,7 +1,7 @@ use wasm_bindgen::{prelude::*, JsValue}; /// Simple Connection -#[wasm_bindgen(module = "/js-to-rust-test/index.js")] +#[wasm_bindgen(module = "/src/package.js")] extern "C" { #[wasm_bindgen(catch)] pub fn batch_execute(database: i32, query: &str) -> Result<(), JsValue>; @@ -11,7 +11,7 @@ extern "C" { } /// Direct Shim for wa-sqlite -#[wasm_bindgen(module = "/js-to-rust-test/index.js")] +#[wasm_bindgen(module = "/src/package.js")] extern "C" { #[wasm_bindgen] pub fn sqlite3_result_text(context: i32, value: String); diff --git a/diesel-wasm-sqlite/src/package.js b/diesel-wasm-sqlite/src/package.js new file mode 100644 index 000000000..a6d80be28 --- /dev/null +++ b/diesel-wasm-sqlite/src/package.js @@ -0,0 +1,2 @@ +var gt=0x7fffffffffffffffn,It=-0x8000000000000000n,Lt=Object.getPrototypeOf(async function(){}).constructor,ue=class extends Error{constructor(p,K){super(p),this.code=K}},Se=!0;function xt(m){let p={};m.retryOps=[];let K=m._getSqliteFree(),n=m._malloc(8),ie=[n,n+4];function te(d){if(typeof d!="string")return 0;let f=new TextEncoder().encode(d),u=m._sqlite3_malloc(f.byteLength+1);return m.HEAPU8.set(f,u),m.HEAPU8[u+f.byteLength]=0,u}function he(d,f){return BigInt(f)<<32n|BigInt(d)&0xffffffffn}let ge=function(){let d=BigInt(Number.MAX_SAFE_INTEGER)>>32n,f=BigInt(Number.MIN_SAFE_INTEGER)>>32n;return function(u,v){return v>d||v2147483647||q<-2147483648)return 25;let w=f(u,v,q);return B(d,w,G.get(u))}}(),p.bind_int64=function(){let d="sqlite3_bind_int64",f=m.cwrap(d,...I("nnnn:n"));return function(u,v,q){if(F(u),q>gt||q>32n,D=f(u,v,Number(w),Number(R));return B(d,D,G.get(u))}}(),p.bind_null=function(){let d="sqlite3_bind_null",f=m.cwrap(d,...I("nn:n"));return function(u,v){F(u);let q=f(u,v);return B(d,q,G.get(u))}}(),p.bind_parameter_name=function(){let f=m.cwrap("sqlite3_bind_parameter_name",...I("n:s"));return function(u,v){return F(u),f(u,v)}}(),p.bind_text=function(){let d="sqlite3_bind_text",f=m.cwrap(d,...I("nnnnn:n"));return function(u,v,q){F(u);let w=te(q),R=f(u,v,w,-1,K);return B(d,R,G.get(u))}}(),p.changes=function(){let f=m.cwrap("sqlite3_changes",...I("n:n"));return function(u){return fe(u),f(u)}}(),p.close=function(){let d="sqlite3_close",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){fe(u);let v=await f(u);return re.delete(u),B(d,v,u)}}(),p.column=function(d,f){F(d);let u=p.column_type(d,f);switch(u){case 4:return p.column_blob(d,f);case 2:return p.column_double(d,f);case 1:let v=p.column_int(d,f),q=m.getTempRet0();return ge(v,q);case 5:return null;case 3:return p.column_text(d,f);default:throw new ue("unknown type",u)}},p.column_blob=function(){let f=m.cwrap("sqlite3_column_blob",...I("nn:n"));return function(u,v){F(u);let q=p.column_bytes(u,v),w=f(u,v);return m.HEAPU8.subarray(w,w+q)}}(),p.column_bytes=function(){let f=m.cwrap("sqlite3_column_bytes",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_count=function(){let f=m.cwrap("sqlite3_column_count",...I("n:n"));return function(u){return F(u),f(u)}}(),p.column_double=function(){let f=m.cwrap("sqlite3_column_double",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_int=function(){let f=m.cwrap("sqlite3_column_int64",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_int64=function(){let f=m.cwrap("sqlite3_column_int64",...I("nn:n"));return function(u,v){F(u);let q=f(u,v),w=m.getTempRet0();return he(q,w)}}(),p.column_name=function(){let f=m.cwrap("sqlite3_column_name",...I("nn:s"));return function(u,v){return F(u),f(u,v)}}(),p.column_names=function(d){let f=[],u=p.column_count(d);for(let v=0;vk(C,m.HEAP32.subarray(Z/4,Z/4+U)):(C,U,Z)=>k(C,m.HEAP32.subarray(Z/4,Z/4+U))}let j=m.create_function(d,f,u,v,q,w&&W(w),R&&W(R),D);return B("sqlite3_create_function",j,d)},p.data_count=function(){let f=m.cwrap("sqlite3_data_count",...I("n:n"));return function(u){return F(u),f(u)}}(),p.exec=async function(d,f,u){for await(let v of p.statements(d,f)){let q;for(;await p.step(v)===100;)if(u){q=q??p.column_names(v);let w=p.row(v);await u(w,q)}}return 0},p.finalize=function(){let f=m.cwrap("sqlite3_finalize",...I("n:n"),{async:Se});return async function(u){let v=await f(u);return G.delete(u),v}}(),p.get_autocommit=function(){let f=m.cwrap("sqlite3_get_autocommit",...I("n:n"));return function(u){return f(u)}}(),p.libversion=function(){let f=m.cwrap("sqlite3_libversion",...I(":s"));return function(){return f()}}(),p.libversion_number=function(){let f=m.cwrap("sqlite3_libversion_number",...I(":n"));return function(){return f()}}(),p.limit=function(){let f=m.cwrap("sqlite3_limit",...I("nnn:n"));return function(u,v,q){return f(u,v,q)}}(),p.open_v2=function(){let d="sqlite3_open_v2",f=m.cwrap(d,...I("snnn:n"),{async:Se});return async function(u,v,q){v=v||6,q=te(q);try{let w=await ae(()=>f(u,ie[0],v,q)),R=m.getValue(ie[0],"*");return re.add(R),m.ccall("RegisterExtensionFunctions","void",["number"],[R]),B(d,w),R}finally{m._sqlite3_free(q)}}}(),p.progress_handler=function(d,f,u,v){fe(d),m.progress_handler(d,f,u,v)},p.reset=function(){let d="sqlite3_reset",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){F(u);let v=await f(u);return B(d,v,G.get(u))}}(),p.result=function(d,f){switch(typeof f){case"number":f===(f|0)?p.result_int(d,f):p.result_double(d,f);break;case"string":p.result_text(d,f);break;default:if(f instanceof Uint8Array||Array.isArray(f))p.result_blob(d,f);else if(f===null)p.result_null(d);else{if(typeof f=="bigint")return p.result_int64(d,f);console.warn("unknown result converted to null",f),p.result_null(d)}break}},p.result_blob=function(){let f=m.cwrap("sqlite3_result_blob",...I("nnnn:n"));return function(u,v){let q=v.byteLength??v.length,w=m._sqlite3_malloc(q);m.HEAPU8.subarray(w).set(v),f(u,w,q,K)}}(),p.result_double=function(){let f=m.cwrap("sqlite3_result_double",...I("nn:n"));return function(u,v){f(u,v)}}(),p.result_int=function(){let f=m.cwrap("sqlite3_result_int",...I("nn:n"));return function(u,v){f(u,v)}}(),p.result_int64=function(){let f=m.cwrap("sqlite3_result_int64",...I("nnn:n"));return function(u,v){if(v>gt||v>32n;f(u,Number(q),Number(w))}}(),p.result_null=function(){let f=m.cwrap("sqlite3_result_null",...I("n:n"));return function(u){f(u)}}(),p.result_text=function(){let f=m.cwrap("sqlite3_result_text",...I("nnnn:n"));return function(u,v){let q=te(v);f(u,q,-1,K)}}(),p.row=function(d){let f=[],u=p.data_count(d);for(let v=0;vR(v(D,W,j,k,C,U)):(D,W,j,k,C,U)=>R(v(D,W,j,k,C,U))}let w=m.set_authorizer(d,q(f),u);return B("sqlite3_set_authorizer",w,d)},p.sql=function(){let f=m.cwrap("sqlite3_sql",...I("n:s"));return function(u){return F(u),f(u)}}(),p.statements=function(d,f,u={}){let v=m.cwrap("sqlite3_prepare_v3","number",["number","number","number","number","number","number"],{async:!0});return async function*(){let q=[];try{let U=function(){C&&!u.unscoped&&p.finalize(C),C=0},w=new TextEncoder().encode(f),R=w.byteLength-w.byteLength%4+12,D=m._sqlite3_malloc(R),W=D+w.byteLength+1;q.push(()=>m._sqlite3_free(D)),m.HEAPU8.set(w,D),m.HEAPU8[W-1]=0;let j=D+R-8,k=D+R-4,C;q.push(U),m.setValue(k,D,"*");do{U();let Z=m.getValue(k,"*"),y=await ae(()=>v(d,Z,W-k,u.flags||0,j,k));y!==0&&B("sqlite3_prepare_v3",y,d),C=m.getValue(j,"*"),C&&(G.set(C,d),yield C)}while(C)}finally{for(;q.length;)q.pop()()}}()},p.step=function(){let d="sqlite3_step",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){F(u);let v=await ae(()=>f(u));return B(d,v,G.get(u),[100,101])}}(),p.value=function(d){let f=p.value_type(d);switch(f){case 4:return p.value_blob(d);case 2:return p.value_double(d);case 1:let u=p.value_int(d),v=m.getTempRet0();return ge(u,v);case 5:return null;case 3:return p.value_text(d);default:throw new ue("unknown type",f)}},p.value_blob=function(){let f=m.cwrap("sqlite3_value_blob",...I("n:n"));return function(u){let v=p.value_bytes(u),q=f(u);return m.HEAPU8.subarray(q,q+v)}}(),p.value_bytes=function(){let f=m.cwrap("sqlite3_value_bytes",...I("n:n"));return function(u){return f(u)}}(),p.value_double=function(){let f=m.cwrap("sqlite3_value_double",...I("n:n"));return function(u){return f(u)}}(),p.value_int=function(){let f=m.cwrap("sqlite3_value_int64",...I("n:n"));return function(u){return f(u)}}(),p.value_int64=function(){let f=m.cwrap("sqlite3_value_int64",...I("n:n"));return function(u){let v=f(u),q=m.getTempRet0();return he(v,q)}}(),p.value_text=function(){let f=m.cwrap("sqlite3_value_text",...I("n:s"));return function(u){return f(u)}}(),p.value_type=function(){let f=m.cwrap("sqlite3_value_type",...I("n:n"));return function(u){return f(u)}}(),p.vfs_register=function(d,f){let u=m.vfs_register(d,f);return B("sqlite3_vfs_register",u)};function B(d,f,u=null,v=[0]){if(v.includes(f))return f;let q=u?m.ccall("sqlite3_errmsg","string",["number"],[u]):d;throw new ue(q,f)}async function ae(d){let f;do m.retryOps.length&&(await Promise.all(m.retryOps),m.retryOps=[]),f=await d();while(f&&m.retryOps.length);return f}return p}function I(m){let p=[],K=m.match(/([ns@]*):([nsv@])/);switch(K[2]){case"n":p.push("number");break;case"s":p.push("string");break;case"v":p.push(null);break}let n=[];for(let ie of K[1])switch(ie){case"n":n.push("number");break;case"s":n.push("string");break}return p.push(n),p}var Ga=(()=>{var m=import.meta.url;return function(p={}){var K,n=p,ie,te,he=new Promise((e,t)=>{ie=e,te=t}),ge=typeof window=="object",re=typeof importScripts=="function",fe=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string",G=Object.assign({},n),F=[],B="./this.program",ae=(e,t)=>{throw t},d="";function f(e){return n.locateFile?n.locateFile(e,d):d+e}var u,v;(ge||re)&&(re?d=self.location.href:typeof document<"u"&&document.currentScript&&(d=document.currentScript.src),m&&(d=m),d.startsWith("blob:")?d="":d=d.substr(0,d.replace(/[?#].*/,"").lastIndexOf("/")+1),re&&(v=e=>{var t=new XMLHttpRequest;return t.open("GET",e,!1),t.responseType="arraybuffer",t.send(null),new Uint8Array(t.response)}),u=e=>fetch(e,{credentials:"same-origin"}).then(t=>t.ok?t.arrayBuffer():Promise.reject(new Error(t.status+" : "+t.url))));var q=n.print||console.log.bind(console),w=n.printErr||console.error.bind(console);Object.assign(n,G),G=null,n.arguments&&(F=n.arguments),n.thisProgram&&(B=n.thisProgram),n.quit&&(ae=n.quit);var R;n.wasmBinary&&(R=n.wasmBinary);var D,W=!1,j,k,C,U,Z,y,z,Oe,Qe;function He(){var e=D.buffer;n.HEAP8=k=new Int8Array(e),n.HEAP16=U=new Int16Array(e),n.HEAPU8=C=new Uint8Array(e),n.HEAPU16=Z=new Uint16Array(e),n.HEAP32=y=new Int32Array(e),n.HEAPU32=z=new Uint32Array(e),n.HEAPF32=Oe=new Float32Array(e),n.HEAPF64=Qe=new Float64Array(e)}var We=[],je=[],At=[],Ge=[],Nt=!1;function Rt(){if(n.preRun)for(typeof n.preRun=="function"&&(n.preRun=[n.preRun]);n.preRun.length;)Ct(n.preRun.shift());xe(We)}function kt(){Nt=!0,!n.noFSInit&&!s.init.initialized&&s.init(),s.ignorePermissions=!1,_e.init(),xe(je)}function Ot(){xe(At)}function Qt(){if(n.postRun)for(typeof n.postRun=="function"&&(n.postRun=[n.postRun]);n.postRun.length;)Pt(n.postRun.shift());xe(Ge)}function Ct(e){We.unshift(e)}function Ft(e){je.unshift(e)}function Pt(e){Ge.unshift(e)}var le=0,Ce=null,be=null;function Ha(e){return e}function Fe(e){le++,n.monitorRunDependencies?.(le)}function Ie(e){if(le--,n.monitorRunDependencies?.(le),le==0&&(Ce!==null&&(clearInterval(Ce),Ce=null),be)){var t=be;be=null,t()}}function ne(e){n.onAbort?.(e),e="Aborted("+e+")",w(e),W=!0,j=1,e+=". Build with -sASSERTIONS for more info.";var t=new WebAssembly.RuntimeError(e);throw te(t),t}var Dt="data:application/octet-stream;base64,",Ke=e=>e.startsWith(Dt);function Mt(){if(n.locateFile){var e="wa-sqlite.wasm";return Ke(e)?e:f(e)}return new URL("wa-sqlite.wasm",import.meta.url).href}var Le;function Xe(e){if(e==Le&&R)return new Uint8Array(R);if(v)return v(e);throw"both async and sync fetching of the wasm failed"}function Ut(e){return R?Promise.resolve().then(()=>Xe(e)):u(e).then(t=>new Uint8Array(t),()=>Xe(e))}function Ve(e,t,r){return Ut(e).then(_=>WebAssembly.instantiate(_,t)).then(r,_=>{w(`failed to asynchronously prepare wasm: ${_}`),ne(_)})}function zt(e,t,r,_){return!e&&typeof WebAssembly.instantiateStreaming=="function"&&!Ke(t)&&typeof fetch=="function"?fetch(t,{credentials:"same-origin"}).then(o=>{var a=WebAssembly.instantiateStreaming(o,r);return a.then(_,function(l){return w(`wasm streaming compile failed: ${l}`),w("falling back to ArrayBuffer instantiation"),Ve(t,r,_)})}):Ve(t,r,_)}function Bt(){return{a:jn}}function Ht(){var e=Bt();function t(_,o){return i=_.exports,D=i.ja,He(),ve=i.af,Ft(i.ka),Ie("wasm-instantiate"),i}Fe("wasm-instantiate");function r(_){t(_.instance)}if(n.instantiateWasm)try{return n.instantiateWasm(e,t)}catch(_){w(`Module.instantiateWasm callback failed with error: ${_}`),te(_)}return Le||(Le=Mt()),zt(R,Le,e,r).catch(te),{}}var S,P;function Ye(e){this.name="ExitStatus",this.message=`Program terminated with exit(${e})`,this.status=e}var xe=e=>{for(;e.length>0;)e.shift()(n)};function $e(e,t="i8"){switch(t.endsWith("*")&&(t="*"),t){case"i1":return k[e];case"i8":return k[e];case"i16":return U[e>>1];case"i32":return y[e>>2];case"i64":ne("to do getValue(i64) use WASM_BIGINT");case"float":return Oe[e>>2];case"double":return Qe[e>>3];case"*":return z[e>>2];default:ne(`invalid type for getValue: ${t}`)}}var Wt=n.noExitRuntime||!0;function Ae(e,t,r="i8"){switch(r.endsWith("*")&&(r="*"),r){case"i1":k[e]=t;break;case"i8":k[e]=t;break;case"i16":U[e>>1]=t;break;case"i32":y[e>>2]=t;break;case"i64":ne("to do setValue(i64) use WASM_BIGINT");case"float":Oe[e>>2]=t;break;case"double":Qe[e>>3]=t;break;case"*":z[e>>2]=t;break;default:ne(`invalid type for setValue: ${r}`)}}var jt=e=>dt(e),Gt=()=>vt(),Ze=typeof TextDecoder<"u"?new TextDecoder:void 0,de=(e,t,r)=>{for(var _=t+r,o=t;e[o]&&!(o>=_);)++o;if(o-t>16&&e.buffer&&Ze)return Ze.decode(e.subarray(t,o));for(var a="";t>10,56320|h&1023)}}return a},ce=(e,t)=>e?de(C,e,t):"",Kt=(e,t,r,_)=>{ne(`Assertion failed: ${ce(e)}, at: `+[t?ce(t):"unknown filename",r,_?ce(_):"unknown function"])},Q={isAbs:e=>e.charAt(0)==="/",splitPath:e=>{var t=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return t.exec(e).slice(1)},normalizeArray:(e,t)=>{for(var r=0,_=e.length-1;_>=0;_--){var o=e[_];o==="."?e.splice(_,1):o===".."?(e.splice(_,1),r++):r&&(e.splice(_,1),r--)}if(t)for(;r;r--)e.unshift("..");return e},normalize:e=>{var t=Q.isAbs(e),r=e.substr(-1)==="/";return e=Q.normalizeArray(e.split("/").filter(_=>!!_),!t).join("/"),!e&&!t&&(e="."),e&&r&&(e+="/"),(t?"/":"")+e},dirname:e=>{var t=Q.splitPath(e),r=t[0],_=t[1];return!r&&!_?".":(_&&(_=_.substr(0,_.length-1)),r+_)},basename:e=>{if(e==="/")return"/";e=Q.normalize(e),e=e.replace(/\/$/,"");var t=e.lastIndexOf("/");return t===-1?e:e.substr(t+1)},join:(...e)=>Q.normalize(e.join("/")),join2:(e,t)=>Q.normalize(e+"/"+t)},Xt=()=>{if(typeof crypto=="object"&&typeof crypto.getRandomValues=="function")return e=>crypto.getRandomValues(e);ne("initRandomDevice")},Je=e=>(Je=Xt())(e),ee={resolve:(...e)=>{for(var t="",r=!1,_=e.length-1;_>=-1&&!r;_--){var o=_>=0?e[_]:s.cwd();if(typeof o!="string")throw new TypeError("Arguments to path.resolve must be strings");if(!o)return"";t=o+"/"+t,r=Q.isAbs(o)}return t=Q.normalizeArray(t.split("/").filter(a=>!!a),!r).join("/"),(r?"/":"")+t||"."},relative:(e,t)=>{e=ee.resolve(e).substr(1),t=ee.resolve(t).substr(1);function r(h){for(var g=0;g=0&&h[A]==="";A--);return g>A?[]:h.slice(g,A-g+1)}for(var _=r(e.split("/")),o=r(t.split("/")),a=Math.min(_.length,o.length),l=a,c=0;c{for(var t=0,r=0;r=55296&&_<=57343?(t+=4,++r):t+=3}return t},De=(e,t,r,_)=>{if(!(_>0))return 0;for(var o=r,a=r+_-1,l=0;l=55296&&c<=57343){var E=e.charCodeAt(++l);c=65536+((c&1023)<<10)|E&1023}if(c<=127){if(r>=a)break;t[r++]=c}else if(c<=2047){if(r+1>=a)break;t[r++]=192|c>>6,t[r++]=128|c&63}else if(c<=65535){if(r+2>=a)break;t[r++]=224|c>>12,t[r++]=128|c>>6&63,t[r++]=128|c&63}else{if(r+3>=a)break;t[r++]=240|c>>18,t[r++]=128|c>>12&63,t[r++]=128|c>>6&63,t[r++]=128|c&63}}return t[r]=0,r-o};function Me(e,t,r){var _=r>0?r:pe(e)+1,o=new Array(_),a=De(e,o,0,o.length);return t&&(o.length=a),o}var Vt=()=>{if(!Pe.length){var e=null;if(typeof window<"u"&&typeof window.prompt=="function"&&(e=window.prompt("Input: "),e!==null&&(e+=` +`)),!e)return null;Pe=Me(e,!0)}return Pe.shift()},_e={ttys:[],init(){},shutdown(){},register(e,t){_e.ttys[e]={input:[],output:[],ops:t},s.registerDevice(e,_e.stream_ops)},stream_ops:{open(e){var t=_e.ttys[e.node.rdev];if(!t)throw new s.ErrnoError(43);e.tty=t,e.seekable=!1},close(e){e.tty.ops.fsync(e.tty)},fsync(e){e.tty.ops.fsync(e.tty)},read(e,t,r,_,o){if(!e.tty||!e.tty.ops.get_char)throw new s.ErrnoError(60);for(var a=0,l=0;l<_;l++){var c;try{c=e.tty.ops.get_char(e.tty)}catch{throw new s.ErrnoError(29)}if(c===void 0&&a===0)throw new s.ErrnoError(6);if(c==null)break;a++,t[r+l]=c}return a&&(e.node.timestamp=Date.now()),a},write(e,t,r,_,o){if(!e.tty||!e.tty.ops.put_char)throw new s.ErrnoError(60);try{for(var a=0;a<_;a++)e.tty.ops.put_char(e.tty,t[r+a])}catch{throw new s.ErrnoError(29)}return _&&(e.node.timestamp=Date.now()),a}},default_tty_ops:{get_char(e){return Vt()},put_char(e,t){t===null||t===10?(q(de(e.output,0)),e.output=[]):t!=0&&e.output.push(t)},fsync(e){e.output&&e.output.length>0&&(q(de(e.output,0)),e.output=[])},ioctl_tcgets(e){return{c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(e,t,r){return 0},ioctl_tiocgwinsz(e){return[24,80]}},default_tty1_ops:{put_char(e,t){t===null||t===10?(w(de(e.output,0)),e.output=[]):t!=0&&e.output.push(t)},fsync(e){e.output&&e.output.length>0&&(w(de(e.output,0)),e.output=[])}}},Yt=(e,t)=>(C.fill(0,e,e+t),e),$t=(e,t)=>Math.ceil(e/t)*t,et=e=>{e=$t(e,65536);var t=ut(65536,e);return t?Yt(t,e):0},L={ops_table:null,mount(e){return L.createNode(null,"/",16895,0)},createNode(e,t,r,_){if(s.isBlkdev(r)||s.isFIFO(r))throw new s.ErrnoError(63);L.ops_table||={dir:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr,lookup:L.node_ops.lookup,mknod:L.node_ops.mknod,rename:L.node_ops.rename,unlink:L.node_ops.unlink,rmdir:L.node_ops.rmdir,readdir:L.node_ops.readdir,symlink:L.node_ops.symlink},stream:{llseek:L.stream_ops.llseek}},file:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr},stream:{llseek:L.stream_ops.llseek,read:L.stream_ops.read,write:L.stream_ops.write,allocate:L.stream_ops.allocate,mmap:L.stream_ops.mmap,msync:L.stream_ops.msync}},link:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr,readlink:L.node_ops.readlink},stream:{}},chrdev:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr},stream:s.chrdev_stream_ops}};var o=s.createNode(e,t,r,_);return s.isDir(o.mode)?(o.node_ops=L.ops_table.dir.node,o.stream_ops=L.ops_table.dir.stream,o.contents={}):s.isFile(o.mode)?(o.node_ops=L.ops_table.file.node,o.stream_ops=L.ops_table.file.stream,o.usedBytes=0,o.contents=null):s.isLink(o.mode)?(o.node_ops=L.ops_table.link.node,o.stream_ops=L.ops_table.link.stream):s.isChrdev(o.mode)&&(o.node_ops=L.ops_table.chrdev.node,o.stream_ops=L.ops_table.chrdev.stream),o.timestamp=Date.now(),e&&(e.contents[t]=o,e.timestamp=o.timestamp),o},getFileDataAsTypedArray(e){return e.contents?e.contents.subarray?e.contents.subarray(0,e.usedBytes):new Uint8Array(e.contents):new Uint8Array(0)},expandFileStorage(e,t){var r=e.contents?e.contents.length:0;if(!(r>=t)){var _=1024*1024;t=Math.max(t,r*(r<_?2:1.125)>>>0),r!=0&&(t=Math.max(t,256));var o=e.contents;e.contents=new Uint8Array(t),e.usedBytes>0&&e.contents.set(o.subarray(0,e.usedBytes),0)}},resizeFileStorage(e,t){if(e.usedBytes!=t)if(t==0)e.contents=null,e.usedBytes=0;else{var r=e.contents;e.contents=new Uint8Array(t),r&&e.contents.set(r.subarray(0,Math.min(t,e.usedBytes))),e.usedBytes=t}},node_ops:{getattr(e){var t={};return t.dev=s.isChrdev(e.mode)?e.id:1,t.ino=e.id,t.mode=e.mode,t.nlink=1,t.uid=0,t.gid=0,t.rdev=e.rdev,s.isDir(e.mode)?t.size=4096:s.isFile(e.mode)?t.size=e.usedBytes:s.isLink(e.mode)?t.size=e.link.length:t.size=0,t.atime=new Date(e.timestamp),t.mtime=new Date(e.timestamp),t.ctime=new Date(e.timestamp),t.blksize=4096,t.blocks=Math.ceil(t.size/t.blksize),t},setattr(e,t){t.mode!==void 0&&(e.mode=t.mode),t.timestamp!==void 0&&(e.timestamp=t.timestamp),t.size!==void 0&&L.resizeFileStorage(e,t.size)},lookup(e,t){throw s.genericErrors[44]},mknod(e,t,r,_){return L.createNode(e,t,r,_)},rename(e,t,r){if(s.isDir(e.mode)){var _;try{_=s.lookupNode(t,r)}catch{}if(_)for(var o in _.contents)throw new s.ErrnoError(55)}delete e.parent.contents[e.name],e.parent.timestamp=Date.now(),e.name=r,t.contents[r]=e,t.timestamp=e.parent.timestamp},unlink(e,t){delete e.contents[t],e.timestamp=Date.now()},rmdir(e,t){var r=s.lookupNode(e,t);for(var _ in r.contents)throw new s.ErrnoError(55);delete e.contents[t],e.timestamp=Date.now()},readdir(e){var t=[".",".."];for(var r of Object.keys(e.contents))t.push(r);return t},symlink(e,t,r){var _=L.createNode(e,t,41471,0);return _.link=r,_},readlink(e){if(!s.isLink(e.mode))throw new s.ErrnoError(28);return e.link}},stream_ops:{read(e,t,r,_,o){var a=e.node.contents;if(o>=e.node.usedBytes)return 0;var l=Math.min(e.node.usedBytes-o,_);if(l>8&&a.subarray)t.set(a.subarray(o,o+l),r);else for(var c=0;c0||r+t{var o=_?"":`al ${e}`;u(e).then(a=>{t(new Uint8Array(a)),o&&Ie(o)},a=>{if(r)r();else throw`Loading data file "${e}" failed.`}),o&&Fe(o)},Jt=(e,t,r,_,o,a)=>{s.createDataFile(e,t,r,_,o,a)},er=n.preloadPlugins||[],tr=(e,t,r,_)=>{typeof Browser<"u"&&Browser.init();var o=!1;return er.forEach(a=>{o||a.canHandle(t)&&(a.handle(e,t,r,_),o=!0)}),o},rr=(e,t,r,_,o,a,l,c,E,h)=>{var g=t?ee.resolve(Q.join2(e,t)):e,A=`cp ${g}`;function x(T){function b(M){h?.(),c||Jt(e,t,M,_,o,E),a?.(),Ie(A)}tr(T,g,b,()=>{l?.(),Ie(A)})||b(T)}Fe(A),typeof r=="string"?Zt(r,x,l):x(r)},nr=e=>{var t={r:0,"r+":2,w:577,"w+":578,a:1089,"a+":1090},r=t[e];if(typeof r>"u")throw new Error(`Unknown file open mode: ${e}`);return r},Ue=(e,t)=>{var r=0;return e&&(r|=365),t&&(r|=146),r},s={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:!1,ignorePermissions:!0,ErrnoError:class{constructor(e){this.name="ErrnoError",this.errno=e}},genericErrors:{},filesystems:null,syncFSRequests:0,FSStream:class{constructor(){this.shared={}}get object(){return this.node}set object(e){this.node=e}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(e){this.shared.flags=e}get position(){return this.shared.position}set position(e){this.shared.position=e}},FSNode:class{constructor(e,t,r,_){e||(e=this),this.parent=e,this.mount=e.mount,this.mounted=null,this.id=s.nextInode++,this.name=t,this.mode=r,this.node_ops={},this.stream_ops={},this.rdev=_,this.readMode=365,this.writeMode=146}get read(){return(this.mode&this.readMode)===this.readMode}set read(e){e?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(e){e?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return s.isDir(this.mode)}get isDevice(){return s.isChrdev(this.mode)}},lookupPath(e,t={}){if(e=ee.resolve(e),!e)return{path:"",node:null};var r={follow_mount:!0,recurse_count:0};if(t=Object.assign(r,t),t.recurse_count>8)throw new s.ErrnoError(32);for(var _=e.split("/").filter(A=>!!A),o=s.root,a="/",l=0;l<_.length;l++){var c=l===_.length-1;if(c&&t.parent)break;if(o=s.lookupNode(o,_[l]),a=Q.join2(a,_[l]),s.isMountpoint(o)&&(!c||c&&t.follow_mount)&&(o=o.mounted.root),!c||t.follow)for(var E=0;s.isLink(o.mode);){var h=s.readlink(a);a=ee.resolve(Q.dirname(a),h);var g=s.lookupPath(a,{recurse_count:t.recurse_count+1});if(o=g.node,E++>40)throw new s.ErrnoError(32)}}return{path:a,node:o}},getPath(e){for(var t;;){if(s.isRoot(e)){var r=e.mount.mountpoint;return t?r[r.length-1]!=="/"?`${r}/${t}`:r+t:r}t=t?`${e.name}/${t}`:e.name,e=e.parent}},hashName(e,t){for(var r=0,_=0;_>>0)%s.nameTable.length},hashAddNode(e){var t=s.hashName(e.parent.id,e.name);e.name_next=s.nameTable[t],s.nameTable[t]=e},hashRemoveNode(e){var t=s.hashName(e.parent.id,e.name);if(s.nameTable[t]===e)s.nameTable[t]=e.name_next;else for(var r=s.nameTable[t];r;){if(r.name_next===e){r.name_next=e.name_next;break}r=r.name_next}},lookupNode(e,t){var r=s.mayLookup(e);if(r)throw new s.ErrnoError(r);for(var _=s.hashName(e.id,t),o=s.nameTable[_];o;o=o.name_next){var a=o.name;if(o.parent.id===e.id&&a===t)return o}return s.lookup(e,t)},createNode(e,t,r,_){var o=new s.FSNode(e,t,r,_);return s.hashAddNode(o),o},destroyNode(e){s.hashRemoveNode(e)},isRoot(e){return e===e.parent},isMountpoint(e){return!!e.mounted},isFile(e){return(e&61440)===32768},isDir(e){return(e&61440)===16384},isLink(e){return(e&61440)===40960},isChrdev(e){return(e&61440)===8192},isBlkdev(e){return(e&61440)===24576},isFIFO(e){return(e&61440)===4096},isSocket(e){return(e&49152)===49152},flagsToPermissionString(e){var t=["r","w","rw"][e&3];return e&512&&(t+="w"),t},nodePermissions(e,t){return s.ignorePermissions?0:t.includes("r")&&!(e.mode&292)||t.includes("w")&&!(e.mode&146)||t.includes("x")&&!(e.mode&73)?2:0},mayLookup(e){if(!s.isDir(e.mode))return 54;var t=s.nodePermissions(e,"x");return t||(e.node_ops.lookup?0:2)},mayCreate(e,t){try{var r=s.lookupNode(e,t);return 20}catch{}return s.nodePermissions(e,"wx")},mayDelete(e,t,r){var _;try{_=s.lookupNode(e,t)}catch(a){return a.errno}var o=s.nodePermissions(e,"wx");if(o)return o;if(r){if(!s.isDir(_.mode))return 54;if(s.isRoot(_)||s.getPath(_)===s.cwd())return 10}else if(s.isDir(_.mode))return 31;return 0},mayOpen(e,t){return e?s.isLink(e.mode)?32:s.isDir(e.mode)&&(s.flagsToPermissionString(t)!=="r"||t&512)?31:s.nodePermissions(e,s.flagsToPermissionString(t)):44},MAX_OPEN_FDS:4096,nextfd(){for(var e=0;e<=s.MAX_OPEN_FDS;e++)if(!s.streams[e])return e;throw new s.ErrnoError(33)},getStreamChecked(e){var t=s.getStream(e);if(!t)throw new s.ErrnoError(8);return t},getStream:e=>s.streams[e],createStream(e,t=-1){return e=Object.assign(new s.FSStream,e),t==-1&&(t=s.nextfd()),e.fd=t,s.streams[t]=e,e},closeStream(e){s.streams[e]=null},dupStream(e,t=-1){var r=s.createStream(e,t);return r.stream_ops?.dup?.(r),r},chrdev_stream_ops:{open(e){var t=s.getDevice(e.node.rdev);e.stream_ops=t.stream_ops,e.stream_ops.open?.(e)},llseek(){throw new s.ErrnoError(70)}},major:e=>e>>8,minor:e=>e&255,makedev:(e,t)=>e<<8|t,registerDevice(e,t){s.devices[e]={stream_ops:t}},getDevice:e=>s.devices[e],getMounts(e){for(var t=[],r=[e];r.length;){var _=r.pop();t.push(_),r.push(..._.mounts)}return t},syncfs(e,t){typeof e=="function"&&(t=e,e=!1),s.syncFSRequests++,s.syncFSRequests>1&&w(`warning: ${s.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);var r=s.getMounts(s.root.mount),_=0;function o(l){return s.syncFSRequests--,t(l)}function a(l){if(l)return a.errored?void 0:(a.errored=!0,o(l));++_>=r.length&&o(null)}r.forEach(l=>{if(!l.type.syncfs)return a(null);l.type.syncfs(l,e,a)})},mount(e,t,r){var _=r==="/",o=!r,a;if(_&&s.root)throw new s.ErrnoError(10);if(!_&&!o){var l=s.lookupPath(r,{follow_mount:!1});if(r=l.path,a=l.node,s.isMountpoint(a))throw new s.ErrnoError(10);if(!s.isDir(a.mode))throw new s.ErrnoError(54)}var c={type:e,opts:t,mountpoint:r,mounts:[]},E=e.mount(c);return E.mount=c,c.root=E,_?s.root=E:a&&(a.mounted=c,a.mount&&a.mount.mounts.push(c)),E},unmount(e){var t=s.lookupPath(e,{follow_mount:!1});if(!s.isMountpoint(t.node))throw new s.ErrnoError(28);var r=t.node,_=r.mounted,o=s.getMounts(_);Object.keys(s.nameTable).forEach(l=>{for(var c=s.nameTable[l];c;){var E=c.name_next;o.includes(c.mount)&&s.destroyNode(c),c=E}}),r.mounted=null;var a=r.mount.mounts.indexOf(_);r.mount.mounts.splice(a,1)},lookup(e,t){return e.node_ops.lookup(e,t)},mknod(e,t,r){var _=s.lookupPath(e,{parent:!0}),o=_.node,a=Q.basename(e);if(!a||a==="."||a==="..")throw new s.ErrnoError(28);var l=s.mayCreate(o,a);if(l)throw new s.ErrnoError(l);if(!o.node_ops.mknod)throw new s.ErrnoError(63);return o.node_ops.mknod(o,a,t,r)},create(e,t){return t=t!==void 0?t:438,t&=4095,t|=32768,s.mknod(e,t,0)},mkdir(e,t){return t=t!==void 0?t:511,t&=1023,t|=16384,s.mknod(e,t,0)},mkdirTree(e,t){for(var r=e.split("/"),_="",o=0;o"u"&&(r=t,t=438),t|=8192,s.mknod(e,t,r)},symlink(e,t){if(!ee.resolve(e))throw new s.ErrnoError(44);var r=s.lookupPath(t,{parent:!0}),_=r.node;if(!_)throw new s.ErrnoError(44);var o=Q.basename(t),a=s.mayCreate(_,o);if(a)throw new s.ErrnoError(a);if(!_.node_ops.symlink)throw new s.ErrnoError(63);return _.node_ops.symlink(_,o,e)},rename(e,t){var r=Q.dirname(e),_=Q.dirname(t),o=Q.basename(e),a=Q.basename(t),l,c,E;if(l=s.lookupPath(e,{parent:!0}),c=l.node,l=s.lookupPath(t,{parent:!0}),E=l.node,!c||!E)throw new s.ErrnoError(44);if(c.mount!==E.mount)throw new s.ErrnoError(75);var h=s.lookupNode(c,o),g=ee.relative(e,_);if(g.charAt(0)!==".")throw new s.ErrnoError(28);if(g=ee.relative(t,r),g.charAt(0)!==".")throw new s.ErrnoError(55);var A;try{A=s.lookupNode(E,a)}catch{}if(h!==A){var x=s.isDir(h.mode),T=s.mayDelete(c,o,x);if(T)throw new s.ErrnoError(T);if(T=A?s.mayDelete(E,a,x):s.mayCreate(E,a),T)throw new s.ErrnoError(T);if(!c.node_ops.rename)throw new s.ErrnoError(63);if(s.isMountpoint(h)||A&&s.isMountpoint(A))throw new s.ErrnoError(10);if(E!==c&&(T=s.nodePermissions(c,"w"),T))throw new s.ErrnoError(T);s.hashRemoveNode(h);try{c.node_ops.rename(h,E,a),h.parent=E}catch(b){throw b}finally{s.hashAddNode(h)}}},rmdir(e){var t=s.lookupPath(e,{parent:!0}),r=t.node,_=Q.basename(e),o=s.lookupNode(r,_),a=s.mayDelete(r,_,!0);if(a)throw new s.ErrnoError(a);if(!r.node_ops.rmdir)throw new s.ErrnoError(63);if(s.isMountpoint(o))throw new s.ErrnoError(10);r.node_ops.rmdir(r,_),s.destroyNode(o)},readdir(e){var t=s.lookupPath(e,{follow:!0}),r=t.node;if(!r.node_ops.readdir)throw new s.ErrnoError(54);return r.node_ops.readdir(r)},unlink(e){var t=s.lookupPath(e,{parent:!0}),r=t.node;if(!r)throw new s.ErrnoError(44);var _=Q.basename(e),o=s.lookupNode(r,_),a=s.mayDelete(r,_,!1);if(a)throw new s.ErrnoError(a);if(!r.node_ops.unlink)throw new s.ErrnoError(63);if(s.isMountpoint(o))throw new s.ErrnoError(10);r.node_ops.unlink(r,_),s.destroyNode(o)},readlink(e){var t=s.lookupPath(e),r=t.node;if(!r)throw new s.ErrnoError(44);if(!r.node_ops.readlink)throw new s.ErrnoError(28);return ee.resolve(s.getPath(r.parent),r.node_ops.readlink(r))},stat(e,t){var r=s.lookupPath(e,{follow:!t}),_=r.node;if(!_)throw new s.ErrnoError(44);if(!_.node_ops.getattr)throw new s.ErrnoError(63);return _.node_ops.getattr(_)},lstat(e){return s.stat(e,!0)},chmod(e,t,r){var _;if(typeof e=="string"){var o=s.lookupPath(e,{follow:!r});_=o.node}else _=e;if(!_.node_ops.setattr)throw new s.ErrnoError(63);_.node_ops.setattr(_,{mode:t&4095|_.mode&-4096,timestamp:Date.now()})},lchmod(e,t){s.chmod(e,t,!0)},fchmod(e,t){var r=s.getStreamChecked(e);s.chmod(r.node,t)},chown(e,t,r,_){var o;if(typeof e=="string"){var a=s.lookupPath(e,{follow:!_});o=a.node}else o=e;if(!o.node_ops.setattr)throw new s.ErrnoError(63);o.node_ops.setattr(o,{timestamp:Date.now()})},lchown(e,t,r){s.chown(e,t,r,!0)},fchown(e,t,r){var _=s.getStreamChecked(e);s.chown(_.node,t,r)},truncate(e,t){if(t<0)throw new s.ErrnoError(28);var r;if(typeof e=="string"){var _=s.lookupPath(e,{follow:!0});r=_.node}else r=e;if(!r.node_ops.setattr)throw new s.ErrnoError(63);if(s.isDir(r.mode))throw new s.ErrnoError(31);if(!s.isFile(r.mode))throw new s.ErrnoError(28);var o=s.nodePermissions(r,"w");if(o)throw new s.ErrnoError(o);r.node_ops.setattr(r,{size:t,timestamp:Date.now()})},ftruncate(e,t){var r=s.getStreamChecked(e);if(!(r.flags&2097155))throw new s.ErrnoError(28);s.truncate(r.node,t)},utime(e,t,r){var _=s.lookupPath(e,{follow:!0}),o=_.node;o.node_ops.setattr(o,{timestamp:Math.max(t,r)})},open(e,t,r){if(e==="")throw new s.ErrnoError(44);t=typeof t=="string"?nr(t):t,t&64?(r=typeof r>"u"?438:r,r=r&4095|32768):r=0;var _;if(typeof e=="object")_=e;else{e=Q.normalize(e);try{var o=s.lookupPath(e,{follow:!(t&131072)});_=o.node}catch{}}var a=!1;if(t&64)if(_){if(t&128)throw new s.ErrnoError(20)}else _=s.mknod(e,r,0),a=!0;if(!_)throw new s.ErrnoError(44);if(s.isChrdev(_.mode)&&(t&=-513),t&65536&&!s.isDir(_.mode))throw new s.ErrnoError(54);if(!a){var l=s.mayOpen(_,t);if(l)throw new s.ErrnoError(l)}t&512&&!a&&s.truncate(_,0),t&=-131713;var c=s.createStream({node:_,path:s.getPath(_),flags:t,seekable:!0,position:0,stream_ops:_.stream_ops,ungotten:[],error:!1});return c.stream_ops.open&&c.stream_ops.open(c),n.logReadFiles&&!(t&1)&&(s.readFiles||(s.readFiles={}),e in s.readFiles||(s.readFiles[e]=1)),c},close(e){if(s.isClosed(e))throw new s.ErrnoError(8);e.getdents&&(e.getdents=null);try{e.stream_ops.close&&e.stream_ops.close(e)}catch(t){throw t}finally{s.closeStream(e.fd)}e.fd=null},isClosed(e){return e.fd===null},llseek(e,t,r){if(s.isClosed(e))throw new s.ErrnoError(8);if(!e.seekable||!e.stream_ops.llseek)throw new s.ErrnoError(70);if(r!=0&&r!=1&&r!=2)throw new s.ErrnoError(28);return e.position=e.stream_ops.llseek(e,t,r),e.ungotten=[],e.position},read(e,t,r,_,o){if(_<0||o<0)throw new s.ErrnoError(28);if(s.isClosed(e))throw new s.ErrnoError(8);if((e.flags&2097155)===1)throw new s.ErrnoError(8);if(s.isDir(e.node.mode))throw new s.ErrnoError(31);if(!e.stream_ops.read)throw new s.ErrnoError(28);var a=typeof o<"u";if(!a)o=e.position;else if(!e.seekable)throw new s.ErrnoError(70);var l=e.stream_ops.read(e,t,r,_,o);return a||(e.position+=l),l},write(e,t,r,_,o,a){if(_<0||o<0)throw new s.ErrnoError(28);if(s.isClosed(e))throw new s.ErrnoError(8);if(!(e.flags&2097155))throw new s.ErrnoError(8);if(s.isDir(e.node.mode))throw new s.ErrnoError(31);if(!e.stream_ops.write)throw new s.ErrnoError(28);e.seekable&&e.flags&1024&&s.llseek(e,0,2);var l=typeof o<"u";if(!l)o=e.position;else if(!e.seekable)throw new s.ErrnoError(70);var c=e.stream_ops.write(e,t,r,_,o,a);return l||(e.position+=c),c},allocate(e,t,r){if(s.isClosed(e))throw new s.ErrnoError(8);if(t<0||r<=0)throw new s.ErrnoError(28);if(!(e.flags&2097155))throw new s.ErrnoError(8);if(!s.isFile(e.node.mode)&&!s.isDir(e.node.mode))throw new s.ErrnoError(43);if(!e.stream_ops.allocate)throw new s.ErrnoError(138);e.stream_ops.allocate(e,t,r)},mmap(e,t,r,_,o){if(_&2&&!(o&2)&&(e.flags&2097155)!==2)throw new s.ErrnoError(2);if((e.flags&2097155)===1)throw new s.ErrnoError(2);if(!e.stream_ops.mmap)throw new s.ErrnoError(43);return e.stream_ops.mmap(e,t,r,_,o)},msync(e,t,r,_,o){return e.stream_ops.msync?e.stream_ops.msync(e,t,r,_,o):0},ioctl(e,t,r){if(!e.stream_ops.ioctl)throw new s.ErrnoError(59);return e.stream_ops.ioctl(e,t,r)},readFile(e,t={}){if(t.flags=t.flags||0,t.encoding=t.encoding||"binary",t.encoding!=="utf8"&&t.encoding!=="binary")throw new Error(`Invalid encoding type "${t.encoding}"`);var r,_=s.open(e,t.flags),o=s.stat(e),a=o.size,l=new Uint8Array(a);return s.read(_,l,0,a,0),t.encoding==="utf8"?r=de(l,0):t.encoding==="binary"&&(r=l),s.close(_),r},writeFile(e,t,r={}){r.flags=r.flags||577;var _=s.open(e,r.flags,r.mode);if(typeof t=="string"){var o=new Uint8Array(pe(t)+1),a=De(t,o,0,o.length);s.write(_,o,0,a,void 0,r.canOwn)}else if(ArrayBuffer.isView(t))s.write(_,t,0,t.byteLength,void 0,r.canOwn);else throw new Error("Unsupported data type");s.close(_)},cwd:()=>s.currentPath,chdir(e){var t=s.lookupPath(e,{follow:!0});if(t.node===null)throw new s.ErrnoError(44);if(!s.isDir(t.node.mode))throw new s.ErrnoError(54);var r=s.nodePermissions(t.node,"x");if(r)throw new s.ErrnoError(r);s.currentPath=t.path},createDefaultDirectories(){s.mkdir("/tmp"),s.mkdir("/home"),s.mkdir("/home/web_user")},createDefaultDevices(){s.mkdir("/dev"),s.registerDevice(s.makedev(1,3),{read:()=>0,write:(_,o,a,l,c)=>l}),s.mkdev("/dev/null",s.makedev(1,3)),_e.register(s.makedev(5,0),_e.default_tty_ops),_e.register(s.makedev(6,0),_e.default_tty1_ops),s.mkdev("/dev/tty",s.makedev(5,0)),s.mkdev("/dev/tty1",s.makedev(6,0));var e=new Uint8Array(1024),t=0,r=()=>(t===0&&(t=Je(e).byteLength),e[--t]);s.createDevice("/dev","random",r),s.createDevice("/dev","urandom",r),s.mkdir("/dev/shm"),s.mkdir("/dev/shm/tmp")},createSpecialDirectories(){s.mkdir("/proc");var e=s.mkdir("/proc/self");s.mkdir("/proc/self/fd"),s.mount({mount(){var t=s.createNode(e,"fd",16895,73);return t.node_ops={lookup(r,_){var o=+_,a=s.getStreamChecked(o),l={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>a.path}};return l.parent=l,l}},t}},{},"/proc/self/fd")},createStandardStreams(){n.stdin?s.createDevice("/dev","stdin",n.stdin):s.symlink("/dev/tty","/dev/stdin"),n.stdout?s.createDevice("/dev","stdout",null,n.stdout):s.symlink("/dev/tty","/dev/stdout"),n.stderr?s.createDevice("/dev","stderr",null,n.stderr):s.symlink("/dev/tty1","/dev/stderr");var e=s.open("/dev/stdin",0),t=s.open("/dev/stdout",1),r=s.open("/dev/stderr",1)},staticInit(){[44].forEach(e=>{s.genericErrors[e]=new s.ErrnoError(e),s.genericErrors[e].stack=""}),s.nameTable=new Array(4096),s.mount(L,{},"/"),s.createDefaultDirectories(),s.createDefaultDevices(),s.createSpecialDirectories(),s.filesystems={MEMFS:L}},init(e,t,r){s.init.initialized=!0,n.stdin=e||n.stdin,n.stdout=t||n.stdout,n.stderr=r||n.stderr,s.createStandardStreams()},quit(){s.init.initialized=!1;for(var e=0;ethis.length-1||T<0)){var b=T%this.chunkSize,M=T/this.chunkSize|0;return this.getter(M)[b]}}setDataGetter(T){this.getter=T}cacheLength(){var T=new XMLHttpRequest;if(T.open("HEAD",r,!1),T.send(null),!(T.status>=200&&T.status<300||T.status===304))throw new Error("Couldn't load "+r+". Status: "+T.status);var b=Number(T.getResponseHeader("Content-length")),M,X=(M=T.getResponseHeader("Accept-Ranges"))&&M==="bytes",V=(M=T.getResponseHeader("Content-Encoding"))&&M==="gzip",Y=1024*1024;X||(Y=b);var $=(J,qe)=>{if(J>qe)throw new Error("invalid range ("+J+", "+qe+") or no bytes requested!");if(qe>b-1)throw new Error("only "+b+" bytes available! programmer error!");var H=new XMLHttpRequest;if(H.open("GET",r,!1),b!==Y&&H.setRequestHeader("Range","bytes="+J+"-"+qe),H.responseType="arraybuffer",H.overrideMimeType&&H.overrideMimeType("text/plain; charset=x-user-defined"),H.send(null),!(H.status>=200&&H.status<300||H.status===304))throw new Error("Couldn't load "+r+". Status: "+H.status);return H.response!==void 0?new Uint8Array(H.response||[]):Me(H.responseText||"",!0)},ye=this;ye.setDataGetter(J=>{var qe=J*Y,H=(J+1)*Y-1;if(H=Math.min(H,b-1),typeof ye.chunks[J]>"u"&&(ye.chunks[J]=$(qe,H)),typeof ye.chunks[J]>"u")throw new Error("doXHR failed!");return ye.chunks[J]}),(V||!b)&&(Y=b=1,b=this.getter(0).length,Y=b,q("LazyFiles on gzip forces download of the whole file when length is accessed")),this._length=b,this._chunkSize=Y,this.lengthKnown=!0}get length(){return this.lengthKnown||this.cacheLength(),this._length}get chunkSize(){return this.lengthKnown||this.cacheLength(),this._chunkSize}}if(typeof XMLHttpRequest<"u"){if(!re)throw"Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";var l=new a,c={isDevice:!1,contents:l}}else var c={isDevice:!1,url:r};var E=s.createFile(e,t,c,_,o);c.contents?E.contents=c.contents:c.url&&(E.contents=null,E.url=c.url),Object.defineProperties(E,{usedBytes:{get:function(){return this.contents.length}}});var h={},g=Object.keys(E.stream_ops);g.forEach(x=>{var T=E.stream_ops[x];h[x]=(...b)=>(s.forceLoadFile(E),T(...b))});function A(x,T,b,M,X){var V=x.node.contents;if(X>=V.length)return 0;var Y=Math.min(V.length-X,M);if(V.slice)for(var $=0;$(s.forceLoadFile(E),A(x,T,b,M,X)),h.mmap=(x,T,b,M,X)=>{s.forceLoadFile(E);var V=et(T);if(!V)throw new s.ErrnoError(48);return A(x,k,V,T,b),{ptr:V,allocated:!0}},E.stream_ops=h,E}},N={DEFAULT_POLLMASK:5,calculateAt(e,t,r){if(Q.isAbs(t))return t;var _;if(e===-100)_=s.cwd();else{var o=N.getStreamFromFD(e);_=o.path}if(t.length==0){if(!r)throw new s.ErrnoError(44);return _}return Q.join2(_,t)},doStat(e,t,r){var _=e(t);y[r>>2]=_.dev,y[r+4>>2]=_.mode,z[r+8>>2]=_.nlink,y[r+12>>2]=_.uid,y[r+16>>2]=_.gid,y[r+20>>2]=_.rdev,P=[_.size>>>0,(S=_.size,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+24>>2]=P[0],y[r+28>>2]=P[1],y[r+32>>2]=4096,y[r+36>>2]=_.blocks;var o=_.atime.getTime(),a=_.mtime.getTime(),l=_.ctime.getTime();return P=[Math.floor(o/1e3)>>>0,(S=Math.floor(o/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+40>>2]=P[0],y[r+44>>2]=P[1],z[r+48>>2]=o%1e3*1e3,P=[Math.floor(a/1e3)>>>0,(S=Math.floor(a/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+56>>2]=P[0],y[r+60>>2]=P[1],z[r+64>>2]=a%1e3*1e3,P=[Math.floor(l/1e3)>>>0,(S=Math.floor(l/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+72>>2]=P[0],y[r+76>>2]=P[1],z[r+80>>2]=l%1e3*1e3,P=[_.ino>>>0,(S=_.ino,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+88>>2]=P[0],y[r+92>>2]=P[1],0},doMsync(e,t,r,_,o){if(!s.isFile(t.node.mode))throw new s.ErrnoError(43);if(_&2)return 0;var a=C.slice(e,e+r);s.msync(t,a,o,r,_)},getStreamFromFD(e){var t=s.getStreamChecked(e);return t},varargs:void 0,getStr(e){var t=ce(e);return t}};function _r(e,t){try{return e=N.getStr(e),s.chmod(e,t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function sr(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t),r&-8)return-28;var o=s.lookupPath(t,{follow:!0}),a=o.node;if(!a)return-44;var l="";return r&4&&(l+="r"),r&2&&(l+="w"),r&1&&(l+="x"),l&&s.nodePermissions(a,l)?-2:0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function or(e,t){try{return s.fchmod(e,t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function ir(e,t,r){try{return s.fchown(e,t,r),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}function Ne(){var e=y[+N.varargs>>2];return N.varargs+=4,e}var ar=Ne;function lr(e,t,r){N.varargs=r;try{var _=N.getStreamFromFD(e);switch(t){case 0:{var o=Ne();if(o<0)return-28;for(;s.streams[o];)o++;var a;return a=s.dupStream(_,o),a.fd}case 1:case 2:return 0;case 3:return _.flags;case 4:{var o=Ne();return _.flags|=o,0}case 12:{var o=ar(),l=0;return U[o+l>>1]=2,0}case 13:case 14:return 0}return-28}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function cr(e,t){try{var r=N.getStreamFromFD(e);return N.doStat(s.stat,r.path,t)}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}var Te=(e,t)=>t+2097152>>>0<4194305-!!e?(e>>>0)+t*4294967296:NaN;function ur(e,t,r){var _=Te(t,r);try{return isNaN(_)?61:(s.ftruncate(e,_),0)}catch(o){if(typeof s>"u"||o.name!=="ErrnoError")throw o;return-o.errno}}var se=(e,t,r)=>De(e,C,t,r);function fr(e,t){try{if(t===0)return-28;var r=s.cwd(),_=pe(r)+1;return t<_?-68:(se(r,e,t),_)}catch(o){if(typeof s>"u"||o.name!=="ErrnoError")throw o;return-o.errno}}function dr(e,t){try{return e=N.getStr(e),N.doStat(s.lstat,e,t)}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function pr(e,t,r){try{return t=N.getStr(t),t=N.calculateAt(e,t),t=Q.normalize(t),t[t.length-1]==="/"&&(t=t.substr(0,t.length-1)),s.mkdir(t,r,0),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}function vr(e,t,r,_){try{t=N.getStr(t);var o=_&256,a=_&4096;return _=_&-6401,t=N.calculateAt(e,t,a),N.doStat(o?s.lstat:s.stat,t,r)}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return-l.errno}}function mr(e,t,r,_){N.varargs=_;try{t=N.getStr(t),t=N.calculateAt(e,t);var o=_?Ne():0;return s.open(t,r,o).fd}catch(a){if(typeof s>"u"||a.name!=="ErrnoError")throw a;return-a.errno}}function Er(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t),_<=0)return-28;var o=s.readlink(t),a=Math.min(_,pe(o)),l=k[r+a];return se(o,r,_+1),k[r+a]=l,a}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function qr(e){try{return e=N.getStr(e),s.rmdir(e),0}catch(t){if(typeof s>"u"||t.name!=="ErrnoError")throw t;return-t.errno}}function hr(e,t){try{return e=N.getStr(e),N.doStat(s.stat,e,t)}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function br(e,t,r){try{return t=N.getStr(t),t=N.calculateAt(e,t),r===0?s.unlink(t):r===512?s.rmdir(t):ne("Invalid flags passed to unlinkat"),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}var tt=e=>z[e>>2]+y[e+4>>2]*4294967296;function Tr(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t,!0),r){var l=tt(r),c=y[r+8>>2];o=l*1e3+c/1e6,r+=16,l=tt(r),c=y[r+8>>2],a=l*1e3+c/1e6}else var o=Date.now(),a=o;return s.utime(t,o,a),0}catch(E){if(typeof s>"u"||E.name!=="ErrnoError")throw E;return-E.errno}}var wr=e=>e%4===0&&(e%100!==0||e%400===0),yr=[0,31,60,91,121,152,182,213,244,274,305,335],Sr=[0,31,59,90,120,151,181,212,243,273,304,334],gr=e=>{var t=wr(e.getFullYear()),r=t?yr:Sr,_=r[e.getMonth()]+e.getDate()-1;return _};function Ir(e,t,r){var _=Te(e,t),o=new Date(_*1e3);y[r>>2]=o.getSeconds(),y[r+4>>2]=o.getMinutes(),y[r+8>>2]=o.getHours(),y[r+12>>2]=o.getDate(),y[r+16>>2]=o.getMonth(),y[r+20>>2]=o.getFullYear()-1900,y[r+24>>2]=o.getDay();var a=gr(o)|0;y[r+28>>2]=a,y[r+36>>2]=-(o.getTimezoneOffset()*60);var l=new Date(o.getFullYear(),0,1),c=new Date(o.getFullYear(),6,1).getTimezoneOffset(),E=l.getTimezoneOffset(),h=(c!=E&&o.getTimezoneOffset()==Math.min(E,c))|0;y[r+32>>2]=h}function Lr(e,t,r,_,o,a,l,c){var E=Te(o,a);try{if(isNaN(E))return 61;var h=N.getStreamFromFD(_),g=s.mmap(h,e,E,t,r),A=g.ptr;return y[l>>2]=g.allocated,z[c>>2]=A,0}catch(x){if(typeof s>"u"||x.name!=="ErrnoError")throw x;return-x.errno}}function xr(e,t,r,_,o,a,l){var c=Te(a,l);try{var E=N.getStreamFromFD(o);r&2&&N.doMsync(e,E,t,_,c)}catch(h){if(typeof s>"u"||h.name!=="ErrnoError")throw h;return-h.errno}}var Ar=(e,t,r,_)=>{var o=new Date().getFullYear(),a=new Date(o,0,1),l=new Date(o,6,1),c=a.getTimezoneOffset(),E=l.getTimezoneOffset(),h=Math.max(c,E);z[e>>2]=h*60,y[t>>2]=+(c!=E);var g=T=>T.toLocaleTimeString(void 0,{hour12:!1,timeZoneName:"short"}).split(" ")[1],A=g(a),x=g(l);EDate.now(),rt;rt=()=>performance.now();var Rr=()=>2147483648,kr=e=>{var t=D.buffer,r=(e-t.byteLength+65535)/65536;try{return D.grow(r),He(),1}catch{}},Or=e=>{var t=C.length;e>>>=0;var r=Rr();if(e>r)return!1;for(var _=(E,h)=>E+(h-E%h)%h,o=1;o<=4;o*=2){var a=t*(1+.2/o);a=Math.min(a,e+100663296);var l=Math.min(r,_(Math.max(e,a),65536)),c=kr(l);if(c)return!0}return!1},ze={},Qr=()=>B||"./this.program",we=()=>{if(!we.strings){var e=(typeof navigator=="object"&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",t={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:e,_:Qr()};for(var r in ze)ze[r]===void 0?delete t[r]:t[r]=ze[r];var _=[];for(var r in t)_.push(`${r}=${t[r]}`);we.strings=_}return we.strings},Cr=(e,t)=>{for(var r=0;r{var r=0;return we().forEach((_,o)=>{var a=t+r;z[e+o*4>>2]=a,Cr(_,a),r+=_.length+1}),0},Pr=(e,t)=>{var r=we();z[e>>2]=r.length;var _=0;return r.forEach(o=>_+=o.length+1),z[t>>2]=_,0};function Dr(e){try{var t=N.getStreamFromFD(e);return s.close(t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return r.errno}}function Mr(e,t){try{var r=0,_=0,o=0,a=N.getStreamFromFD(e),l=a.tty?2:s.isDir(a.mode)?3:s.isLink(a.mode)?7:4;return k[t]=l,U[t+2>>1]=o,P=[r>>>0,(S=r,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[t+8>>2]=P[0],y[t+12>>2]=P[1],P=[_>>>0,(S=_,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[t+16>>2]=P[0],y[t+20>>2]=P[1],0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return c.errno}}var Ur=(e,t,r,_)=>{for(var o=0,a=0;a>2],c=z[t+4>>2];t+=8;var E=s.read(e,k,l,c,_);if(E<0)return-1;if(o+=E,E>2]=a,0}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return l.errno}}function Br(e,t,r,_,o){var a=Te(t,r);try{if(isNaN(a))return 61;var l=N.getStreamFromFD(e);return s.llseek(l,a,_),P=[l.position>>>0,(S=l.position,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[o>>2]=P[0],y[o+4>>2]=P[1],l.getdents&&a===0&&_===0&&(l.getdents=null),0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return c.errno}}function Hr(e){try{var t=N.getStreamFromFD(e);return t.stream_ops?.fsync?t.stream_ops.fsync(t):0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return r.errno}}var Wr=(e,t,r,_)=>{for(var o=0,a=0;a>2],c=z[t+4>>2];t+=8;var E=s.write(e,k,l,c,_);if(E<0)return-1;o+=E,typeof _<"u"&&(_+=E)}return o};function jr(e,t,r,_){try{var o=N.getStreamFromFD(e),a=Wr(o,t,r);return z[_>>2]=a,0}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return l.errno}}var O=function(){let e=typeof Asyncify=="object"?Asyncify.handleAsync.bind(Asyncify):null;n.handleAsync=e;let t=new Map;n.setCallback=(r,_)=>t.set(r,_),n.getCallback=r=>t.get(r),n.deleteCallback=r=>t.delete(r),O=function(r,_,...o){let a=t.get(_),l=null,c=typeof a=="function"?a:a[l=ce(o.shift())];if(r){if(e)return e(()=>c.apply(a,o));throw new Error("Synchronous WebAssembly cannot call async function")}let E=c.apply(a,o);if(typeof E?.then=="function")throw console.error("unexpected Promise",c),new Error(`${l} unexpectedly returned a Promise`);return E}};function Gr(...e){return O(!1,...e)}function Kr(...e){return O(!0,...e)}function Xr(...e){return O(!1,...e)}function Vr(...e){return O(!0,...e)}function Yr(...e){return O(!1,...e)}function $r(...e){return O(!0,...e)}function Zr(...e){return O(!1,...e)}function Jr(...e){return O(!0,...e)}function en(...e){return O(!1,...e)}function tn(...e){return O(!0,...e)}function rn(...e){return O(!1,...e)}function nn(...e){return O(!0,...e)}function _n(...e){return O(!1,...e)}function sn(...e){return O(!0,...e)}function on(...e){return O(!1,...e)}function an(...e){return O(!0,...e)}function ln(...e){return O(!1,...e)}function cn(...e){return O(!0,...e)}function un(...e){return O(!1,...e)}function fn(...e){return O(!0,...e)}function dn(...e){return O(!1,...e)}function pn(...e){return O(!0,...e)}function vn(...e){return O(!1,...e)}function mn(...e){return O(!0,...e)}function En(...e){return O(!1,...e)}function qn(...e){return O(!0,...e)}function hn(...e){return O(!1,...e)}function bn(...e){return O(!0,...e)}function Tn(...e){return O(!1,...e)}function wn(...e){return O(!0,...e)}var yn=0,Sn=()=>Wt||yn>0,gn=e=>{j=e,Sn()||(n.onExit?.(e),W=!0),ae(e,new Ye(e))},In=(e,t)=>{j=e,gn(e)},Ln=e=>{if(e instanceof Ye||e=="unwind")return j;ae(1,e)},nt=(e,t)=>{e<128?t.push(e):t.push(e%128|128,e>>7)},xn=e=>{for(var t={i:"i32",j:"i64",f:"f32",d:"f64",e:"externref",p:"i32"},r={parameters:[],results:e[0]=="v"?[]:[t[e[0]]]},_=1;_{var r=e.slice(0,1),_=e.slice(1),o={i:127,p:127,j:126,f:125,d:124,e:111};t.push(96),nt(_.length,t);for(var a=0;a<_.length;++a)t.push(o[_[a]]);r=="v"?t.push(0):t.push(1,o[r])},Nn=(e,t)=>{if(typeof WebAssembly.Function=="function")return new WebAssembly.Function(xn(t),e);var r=[1];An(t,r);var _=[0,97,115,109,1,0,0,0,1];nt(r.length,_),_.push(...r),_.push(2,7,1,1,101,1,102,0,0,7,5,1,1,102,0,0);var o=new WebAssembly.Module(new Uint8Array(_)),a=new WebAssembly.Instance(o,{e:{f:e}}),l=a.exports.f;return l},ve,Rn=e=>ve.get(e),kn=(e,t)=>{if(me)for(var r=e;r(me||(me=new WeakMap,kn(0,ve.length)),me.get(e)||0),_t=[],Qn=()=>{if(_t.length)return _t.pop();try{ve.grow(1)}catch(e){throw e instanceof RangeError?"Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.":e}return ve.length-1},st=(e,t)=>ve.set(e,t),Cn=(e,t)=>{var r=On(e);if(r)return r;var _=Qn();try{st(_,e)}catch(a){if(!(a instanceof TypeError))throw a;var o=Nn(e,t);st(_,o)}return me.set(e,_),_},ot=e=>{var t=n["_"+e];return t},it=(e,t)=>{k.set(e,t)},at=e=>pt(e),Fn=e=>{var t=pe(e)+1,r=at(t);return se(e,r,t),r},Ee=(e,t,r,_,o)=>{var a={string:b=>{var M=0;return b!=null&&b!==0&&(M=Fn(b)),M},array:b=>{var M=at(b.length);return it(b,M),M}};function l(b){return t==="string"?ce(b):t==="boolean"?!!b:b}var c=ot(e),E=[],h=0;if(_)for(var g=0;g<_.length;g++){var A=a[r[g]];A?(h===0&&(h=Gt()),E[g]=A(_[g])):E[g]=_[g]}var x=c(...E);function T(b){return h!==0&&jt(h),l(b)}return x=T(x),x},Pn=(e,t,r,_)=>{var o=!r||r.every(l=>l==="number"||l==="boolean"),a=t!=="string";return a&&o&&!_?ot(e):(...l)=>Ee(e,t,r,l,_)},Dn=e=>ft(),Mn=(e,t,r)=>{if(r??=2147483647,r<2)return 0;r-=2;for(var _=t,o=r>1]=l,t+=2}return U[t>>1]=0,t-_},Un=(e,t,r)=>{if(r??=2147483647,r<4)return 0;for(var _=t,o=_+r-4,a=0;a=55296&&l<=57343){var c=e.charCodeAt(++a);l=65536+((l&1023)<<10)|c&1023}if(y[t>>2]=l,t+=4,t+4>o)break}return y[t>>2]=0,t-_},zn=e=>{for(var t="";;){var r=C[e++];if(!r)return t;t+=String.fromCharCode(r)}},lt=typeof TextDecoder<"u"?new TextDecoder("utf-16le"):void 0,Bn=(e,t)=>{for(var r=e,_=r>>1,o=_+t/2;!(_>=o)&&Z[_];)++_;if(r=_<<1,r-e>32&<)return lt.decode(C.subarray(e,r));for(var a="",l=0;!(l>=t/2);++l){var c=U[e+l*2>>1];if(c==0)break;a+=String.fromCharCode(c)}return a},Hn=(e,t)=>{for(var r=0,_="";!(r>=t/4);){var o=y[e+r*4>>2];if(o==0)break;if(++r,o>=65536){var a=o-65536;_+=String.fromCharCode(55296|a>>10,56320|a&1023)}else _+=String.fromCharCode(o)}return _};function Wn(e){for(var t=[],r=0;r255&&(_&=255),t.push(String.fromCharCode(_))}return t.join("")}s.createPreloadedFile=rr,s.staticInit(),O();var jn={a:Kt,Y:_r,$:sr,Z:or,X:ir,b:lr,W:cr,y:ur,Q:fr,U:dr,N:pr,T:vr,L:mr,J:Er,I:qr,V:hr,G:br,F:Tr,w:Ir,u:Lr,v:xr,M:Ar,n:Nr,m:rt,D:Or,O:Fr,P:Pr,o:Dr,E:Mr,K:zr,x:Br,S:Hr,H:jr,s:Gr,t:Kr,fa:Xr,ia:Vr,i:Yr,j:$r,c:Zr,d:Jr,ca:en,da:tn,ea:rn,ga:nn,g:_n,h:sn,z:on,A:an,e:ln,f:cn,aa:un,ba:fn,B:dn,C:pn,p:vn,q:mn,ha:En,r:qn,k:hn,l:bn,R:Tn,_:wn},i=Ht(),Gn=()=>(Gn=i.ka)(),Kn=n._sqlite3_status64=(e,t,r,_)=>(Kn=n._sqlite3_status64=i.la)(e,t,r,_),Xn=n._sqlite3_status=(e,t,r,_)=>(Xn=n._sqlite3_status=i.ma)(e,t,r,_),Vn=n._sqlite3_db_status=(e,t,r,_,o)=>(Vn=n._sqlite3_db_status=i.na)(e,t,r,_,o),Yn=n._sqlite3_msize=e=>(Yn=n._sqlite3_msize=i.oa)(e),$n=n._sqlite3_vfs_find=e=>($n=n._sqlite3_vfs_find=i.pa)(e),Zn=n._sqlite3_vfs_register=(e,t)=>(Zn=n._sqlite3_vfs_register=i.qa)(e,t),Jn=n._sqlite3_vfs_unregister=e=>(Jn=n._sqlite3_vfs_unregister=i.ra)(e),e_=n._sqlite3_release_memory=e=>(e_=n._sqlite3_release_memory=i.sa)(e),t_=n._sqlite3_soft_heap_limit64=(e,t)=>(t_=n._sqlite3_soft_heap_limit64=i.ta)(e,t),r_=n._sqlite3_memory_used=()=>(r_=n._sqlite3_memory_used=i.ua)(),n_=n._sqlite3_hard_heap_limit64=(e,t)=>(n_=n._sqlite3_hard_heap_limit64=i.va)(e,t),__=n._sqlite3_memory_highwater=e=>(__=n._sqlite3_memory_highwater=i.wa)(e),s_=n._sqlite3_malloc=e=>(s_=n._sqlite3_malloc=i.xa)(e),o_=n._sqlite3_malloc64=(e,t)=>(o_=n._sqlite3_malloc64=i.ya)(e,t),i_=n._sqlite3_free=e=>(i_=n._sqlite3_free=i.za)(e),a_=n._sqlite3_realloc=(e,t)=>(a_=n._sqlite3_realloc=i.Aa)(e,t),l_=n._sqlite3_realloc64=(e,t,r)=>(l_=n._sqlite3_realloc64=i.Ba)(e,t,r),c_=n._sqlite3_str_vappendf=(e,t,r)=>(c_=n._sqlite3_str_vappendf=i.Ca)(e,t,r),u_=n._sqlite3_str_append=(e,t,r)=>(u_=n._sqlite3_str_append=i.Da)(e,t,r),f_=n._sqlite3_str_appendchar=(e,t,r)=>(f_=n._sqlite3_str_appendchar=i.Ea)(e,t,r),d_=n._sqlite3_str_appendall=(e,t)=>(d_=n._sqlite3_str_appendall=i.Fa)(e,t),p_=n._sqlite3_str_appendf=(e,t,r)=>(p_=n._sqlite3_str_appendf=i.Ga)(e,t,r),v_=n._sqlite3_str_finish=e=>(v_=n._sqlite3_str_finish=i.Ha)(e),m_=n._sqlite3_str_errcode=e=>(m_=n._sqlite3_str_errcode=i.Ia)(e),E_=n._sqlite3_str_length=e=>(E_=n._sqlite3_str_length=i.Ja)(e),q_=n._sqlite3_str_value=e=>(q_=n._sqlite3_str_value=i.Ka)(e),h_=n._sqlite3_str_reset=e=>(h_=n._sqlite3_str_reset=i.La)(e),b_=n._sqlite3_str_new=e=>(b_=n._sqlite3_str_new=i.Ma)(e),T_=n._sqlite3_vmprintf=(e,t)=>(T_=n._sqlite3_vmprintf=i.Na)(e,t),w_=n._sqlite3_mprintf=(e,t)=>(w_=n._sqlite3_mprintf=i.Oa)(e,t),y_=n._sqlite3_vsnprintf=(e,t,r,_)=>(y_=n._sqlite3_vsnprintf=i.Pa)(e,t,r,_),S_=n._sqlite3_snprintf=(e,t,r,_)=>(S_=n._sqlite3_snprintf=i.Qa)(e,t,r,_),g_=n._sqlite3_log=(e,t,r)=>(g_=n._sqlite3_log=i.Ra)(e,t,r),I_=n._sqlite3_randomness=(e,t)=>(I_=n._sqlite3_randomness=i.Sa)(e,t),L_=n._sqlite3_stricmp=(e,t)=>(L_=n._sqlite3_stricmp=i.Ta)(e,t),x_=n._sqlite3_strnicmp=(e,t,r)=>(x_=n._sqlite3_strnicmp=i.Ua)(e,t,r),A_=n._sqlite3_os_init=()=>(A_=n._sqlite3_os_init=i.Va)(),N_=n._sqlite3_os_end=()=>(N_=n._sqlite3_os_end=i.Wa)(),R_=n._sqlite3_serialize=(e,t,r,_)=>(R_=n._sqlite3_serialize=i.Xa)(e,t,r,_),k_=n._sqlite3_prepare_v2=(e,t,r,_,o)=>(k_=n._sqlite3_prepare_v2=i.Ya)(e,t,r,_,o),O_=n._sqlite3_step=e=>(O_=n._sqlite3_step=i.Za)(e),Q_=n._sqlite3_column_int64=(e,t)=>(Q_=n._sqlite3_column_int64=i._a)(e,t),C_=n._sqlite3_reset=e=>(C_=n._sqlite3_reset=i.$a)(e),F_=n._sqlite3_exec=(e,t,r,_,o)=>(F_=n._sqlite3_exec=i.ab)(e,t,r,_,o),P_=n._sqlite3_column_int=(e,t)=>(P_=n._sqlite3_column_int=i.bb)(e,t),D_=n._sqlite3_finalize=e=>(D_=n._sqlite3_finalize=i.cb)(e),M_=n._sqlite3_deserialize=(e,t,r,_,o,a,l,c)=>(M_=n._sqlite3_deserialize=i.db)(e,t,r,_,o,a,l,c),U_=n._sqlite3_database_file_object=e=>(U_=n._sqlite3_database_file_object=i.eb)(e),z_=n._sqlite3_backup_init=(e,t,r,_)=>(z_=n._sqlite3_backup_init=i.fb)(e,t,r,_),B_=n._sqlite3_backup_step=(e,t)=>(B_=n._sqlite3_backup_step=i.gb)(e,t),H_=n._sqlite3_backup_finish=e=>(H_=n._sqlite3_backup_finish=i.hb)(e),W_=n._sqlite3_backup_remaining=e=>(W_=n._sqlite3_backup_remaining=i.ib)(e),j_=n._sqlite3_backup_pagecount=e=>(j_=n._sqlite3_backup_pagecount=i.jb)(e),G_=n._sqlite3_clear_bindings=e=>(G_=n._sqlite3_clear_bindings=i.kb)(e),K_=n._sqlite3_value_blob=e=>(K_=n._sqlite3_value_blob=i.lb)(e),X_=n._sqlite3_value_text=e=>(X_=n._sqlite3_value_text=i.mb)(e),V_=n._sqlite3_value_bytes=e=>(V_=n._sqlite3_value_bytes=i.nb)(e),Y_=n._sqlite3_value_bytes16=e=>(Y_=n._sqlite3_value_bytes16=i.ob)(e),$_=n._sqlite3_value_double=e=>($_=n._sqlite3_value_double=i.pb)(e),Z_=n._sqlite3_value_int=e=>(Z_=n._sqlite3_value_int=i.qb)(e),J_=n._sqlite3_value_int64=e=>(J_=n._sqlite3_value_int64=i.rb)(e),es=n._sqlite3_value_subtype=e=>(es=n._sqlite3_value_subtype=i.sb)(e),ts=n._sqlite3_value_pointer=(e,t)=>(ts=n._sqlite3_value_pointer=i.tb)(e,t),rs=n._sqlite3_value_text16=e=>(rs=n._sqlite3_value_text16=i.ub)(e),ns=n._sqlite3_value_text16be=e=>(ns=n._sqlite3_value_text16be=i.vb)(e),_s=n._sqlite3_value_text16le=e=>(_s=n._sqlite3_value_text16le=i.wb)(e),ss=n._sqlite3_value_type=e=>(ss=n._sqlite3_value_type=i.xb)(e),os=n._sqlite3_value_encoding=e=>(os=n._sqlite3_value_encoding=i.yb)(e),is=n._sqlite3_value_nochange=e=>(is=n._sqlite3_value_nochange=i.zb)(e),as=n._sqlite3_value_frombind=e=>(as=n._sqlite3_value_frombind=i.Ab)(e),ls=n._sqlite3_value_dup=e=>(ls=n._sqlite3_value_dup=i.Bb)(e),cs=n._sqlite3_value_free=e=>(cs=n._sqlite3_value_free=i.Cb)(e),us=n._sqlite3_result_blob=(e,t,r,_)=>(us=n._sqlite3_result_blob=i.Db)(e,t,r,_),fs=n._sqlite3_result_blob64=(e,t,r,_,o)=>(fs=n._sqlite3_result_blob64=i.Eb)(e,t,r,_,o),ds=n._sqlite3_result_double=(e,t)=>(ds=n._sqlite3_result_double=i.Fb)(e,t),ps=n._sqlite3_result_error=(e,t,r)=>(ps=n._sqlite3_result_error=i.Gb)(e,t,r),vs=n._sqlite3_result_error16=(e,t,r)=>(vs=n._sqlite3_result_error16=i.Hb)(e,t,r),ms=n._sqlite3_result_int=(e,t)=>(ms=n._sqlite3_result_int=i.Ib)(e,t),Es=n._sqlite3_result_int64=(e,t,r)=>(Es=n._sqlite3_result_int64=i.Jb)(e,t,r),qs=n._sqlite3_result_null=e=>(qs=n._sqlite3_result_null=i.Kb)(e),hs=n._sqlite3_result_pointer=(e,t,r,_)=>(hs=n._sqlite3_result_pointer=i.Lb)(e,t,r,_),bs=n._sqlite3_result_subtype=(e,t)=>(bs=n._sqlite3_result_subtype=i.Mb)(e,t),Ts=n._sqlite3_result_text=(e,t,r,_)=>(Ts=n._sqlite3_result_text=i.Nb)(e,t,r,_),ws=n._sqlite3_result_text64=(e,t,r,_,o,a)=>(ws=n._sqlite3_result_text64=i.Ob)(e,t,r,_,o,a),ys=n._sqlite3_result_text16=(e,t,r,_)=>(ys=n._sqlite3_result_text16=i.Pb)(e,t,r,_),Ss=n._sqlite3_result_text16be=(e,t,r,_)=>(Ss=n._sqlite3_result_text16be=i.Qb)(e,t,r,_),gs=n._sqlite3_result_text16le=(e,t,r,_)=>(gs=n._sqlite3_result_text16le=i.Rb)(e,t,r,_),Is=n._sqlite3_result_value=(e,t)=>(Is=n._sqlite3_result_value=i.Sb)(e,t),Ls=n._sqlite3_result_error_toobig=e=>(Ls=n._sqlite3_result_error_toobig=i.Tb)(e),xs=n._sqlite3_result_zeroblob=(e,t)=>(xs=n._sqlite3_result_zeroblob=i.Ub)(e,t),As=n._sqlite3_result_zeroblob64=(e,t,r)=>(As=n._sqlite3_result_zeroblob64=i.Vb)(e,t,r),Ns=n._sqlite3_result_error_code=(e,t)=>(Ns=n._sqlite3_result_error_code=i.Wb)(e,t),Rs=n._sqlite3_result_error_nomem=e=>(Rs=n._sqlite3_result_error_nomem=i.Xb)(e),ks=n._sqlite3_user_data=e=>(ks=n._sqlite3_user_data=i.Yb)(e),Os=n._sqlite3_context_db_handle=e=>(Os=n._sqlite3_context_db_handle=i.Zb)(e),Qs=n._sqlite3_vtab_nochange=e=>(Qs=n._sqlite3_vtab_nochange=i._b)(e),Cs=n._sqlite3_vtab_in_first=(e,t)=>(Cs=n._sqlite3_vtab_in_first=i.$b)(e,t),Fs=n._sqlite3_vtab_in_next=(e,t)=>(Fs=n._sqlite3_vtab_in_next=i.ac)(e,t),Ps=n._sqlite3_aggregate_context=(e,t)=>(Ps=n._sqlite3_aggregate_context=i.bc)(e,t),Ds=n._sqlite3_get_auxdata=(e,t)=>(Ds=n._sqlite3_get_auxdata=i.cc)(e,t),Ms=n._sqlite3_set_auxdata=(e,t,r,_)=>(Ms=n._sqlite3_set_auxdata=i.dc)(e,t,r,_),Us=n._sqlite3_column_count=e=>(Us=n._sqlite3_column_count=i.ec)(e),zs=n._sqlite3_data_count=e=>(zs=n._sqlite3_data_count=i.fc)(e),Bs=n._sqlite3_column_blob=(e,t)=>(Bs=n._sqlite3_column_blob=i.gc)(e,t),Hs=n._sqlite3_column_bytes=(e,t)=>(Hs=n._sqlite3_column_bytes=i.hc)(e,t),Ws=n._sqlite3_column_bytes16=(e,t)=>(Ws=n._sqlite3_column_bytes16=i.ic)(e,t),js=n._sqlite3_column_double=(e,t)=>(js=n._sqlite3_column_double=i.jc)(e,t),Gs=n._sqlite3_column_text=(e,t)=>(Gs=n._sqlite3_column_text=i.kc)(e,t),Ks=n._sqlite3_column_value=(e,t)=>(Ks=n._sqlite3_column_value=i.lc)(e,t),Xs=n._sqlite3_column_text16=(e,t)=>(Xs=n._sqlite3_column_text16=i.mc)(e,t),Vs=n._sqlite3_column_type=(e,t)=>(Vs=n._sqlite3_column_type=i.nc)(e,t),Ys=n._sqlite3_column_name=(e,t)=>(Ys=n._sqlite3_column_name=i.oc)(e,t),$s=n._sqlite3_column_name16=(e,t)=>($s=n._sqlite3_column_name16=i.pc)(e,t),Zs=n._sqlite3_bind_blob=(e,t,r,_,o)=>(Zs=n._sqlite3_bind_blob=i.qc)(e,t,r,_,o),Js=n._sqlite3_bind_blob64=(e,t,r,_,o,a)=>(Js=n._sqlite3_bind_blob64=i.rc)(e,t,r,_,o,a),eo=n._sqlite3_bind_double=(e,t,r)=>(eo=n._sqlite3_bind_double=i.sc)(e,t,r),to=n._sqlite3_bind_int=(e,t,r)=>(to=n._sqlite3_bind_int=i.tc)(e,t,r),ro=n._sqlite3_bind_int64=(e,t,r,_)=>(ro=n._sqlite3_bind_int64=i.uc)(e,t,r,_),no=n._sqlite3_bind_null=(e,t)=>(no=n._sqlite3_bind_null=i.vc)(e,t),_o=n._sqlite3_bind_pointer=(e,t,r,_,o)=>(_o=n._sqlite3_bind_pointer=i.wc)(e,t,r,_,o),so=n._sqlite3_bind_text=(e,t,r,_,o)=>(so=n._sqlite3_bind_text=i.xc)(e,t,r,_,o),oo=n._sqlite3_bind_text64=(e,t,r,_,o,a,l)=>(oo=n._sqlite3_bind_text64=i.yc)(e,t,r,_,o,a,l),io=n._sqlite3_bind_text16=(e,t,r,_,o)=>(io=n._sqlite3_bind_text16=i.zc)(e,t,r,_,o),ao=n._sqlite3_bind_value=(e,t,r)=>(ao=n._sqlite3_bind_value=i.Ac)(e,t,r),lo=n._sqlite3_bind_zeroblob=(e,t,r)=>(lo=n._sqlite3_bind_zeroblob=i.Bc)(e,t,r),co=n._sqlite3_bind_zeroblob64=(e,t,r,_)=>(co=n._sqlite3_bind_zeroblob64=i.Cc)(e,t,r,_),uo=n._sqlite3_bind_parameter_count=e=>(uo=n._sqlite3_bind_parameter_count=i.Dc)(e),fo=n._sqlite3_bind_parameter_name=(e,t)=>(fo=n._sqlite3_bind_parameter_name=i.Ec)(e,t),po=n._sqlite3_bind_parameter_index=(e,t)=>(po=n._sqlite3_bind_parameter_index=i.Fc)(e,t),vo=n._sqlite3_db_handle=e=>(vo=n._sqlite3_db_handle=i.Gc)(e),mo=n._sqlite3_stmt_readonly=e=>(mo=n._sqlite3_stmt_readonly=i.Hc)(e),Eo=n._sqlite3_stmt_isexplain=e=>(Eo=n._sqlite3_stmt_isexplain=i.Ic)(e),qo=n._sqlite3_stmt_explain=(e,t)=>(qo=n._sqlite3_stmt_explain=i.Jc)(e,t),ho=n._sqlite3_stmt_busy=e=>(ho=n._sqlite3_stmt_busy=i.Kc)(e),bo=n._sqlite3_next_stmt=(e,t)=>(bo=n._sqlite3_next_stmt=i.Lc)(e,t),To=n._sqlite3_stmt_status=(e,t,r)=>(To=n._sqlite3_stmt_status=i.Mc)(e,t,r),wo=n._sqlite3_sql=e=>(wo=n._sqlite3_sql=i.Nc)(e),yo=n._sqlite3_expanded_sql=e=>(yo=n._sqlite3_expanded_sql=i.Oc)(e),So=n._sqlite3_value_numeric_type=e=>(So=n._sqlite3_value_numeric_type=i.Pc)(e),go=n._sqlite3_blob_open=(e,t,r,_,o,a,l,c)=>(go=n._sqlite3_blob_open=i.Qc)(e,t,r,_,o,a,l,c),Io=n._sqlite3_blob_close=e=>(Io=n._sqlite3_blob_close=i.Rc)(e),Lo=n._sqlite3_blob_read=(e,t,r,_)=>(Lo=n._sqlite3_blob_read=i.Sc)(e,t,r,_),xo=n._sqlite3_blob_write=(e,t,r,_)=>(xo=n._sqlite3_blob_write=i.Tc)(e,t,r,_),Ao=n._sqlite3_blob_bytes=e=>(Ao=n._sqlite3_blob_bytes=i.Uc)(e),No=n._sqlite3_blob_reopen=(e,t,r)=>(No=n._sqlite3_blob_reopen=i.Vc)(e,t,r),Ro=n._sqlite3_set_authorizer=(e,t,r)=>(Ro=n._sqlite3_set_authorizer=i.Wc)(e,t,r),ko=n._sqlite3_strglob=(e,t)=>(ko=n._sqlite3_strglob=i.Xc)(e,t),Oo=n._sqlite3_strlike=(e,t,r)=>(Oo=n._sqlite3_strlike=i.Yc)(e,t,r),Qo=n._sqlite3_errmsg=e=>(Qo=n._sqlite3_errmsg=i.Zc)(e),Co=n._sqlite3_auto_extension=e=>(Co=n._sqlite3_auto_extension=i._c)(e),Fo=n._sqlite3_cancel_auto_extension=e=>(Fo=n._sqlite3_cancel_auto_extension=i.$c)(e),Po=n._sqlite3_reset_auto_extension=()=>(Po=n._sqlite3_reset_auto_extension=i.ad)(),Do=n._sqlite3_prepare=(e,t,r,_,o)=>(Do=n._sqlite3_prepare=i.bd)(e,t,r,_,o),Mo=n._sqlite3_prepare_v3=(e,t,r,_,o,a)=>(Mo=n._sqlite3_prepare_v3=i.cd)(e,t,r,_,o,a),Uo=n._sqlite3_prepare16=(e,t,r,_,o)=>(Uo=n._sqlite3_prepare16=i.dd)(e,t,r,_,o),zo=n._sqlite3_prepare16_v2=(e,t,r,_,o)=>(zo=n._sqlite3_prepare16_v2=i.ed)(e,t,r,_,o),Bo=n._sqlite3_prepare16_v3=(e,t,r,_,o,a)=>(Bo=n._sqlite3_prepare16_v3=i.fd)(e,t,r,_,o,a),Ho=n._sqlite3_get_table=(e,t,r,_,o,a)=>(Ho=n._sqlite3_get_table=i.gd)(e,t,r,_,o,a),Wo=n._sqlite3_free_table=e=>(Wo=n._sqlite3_free_table=i.hd)(e),jo=n._sqlite3_create_module=(e,t,r,_)=>(jo=n._sqlite3_create_module=i.id)(e,t,r,_),Go=n._sqlite3_create_module_v2=(e,t,r,_,o)=>(Go=n._sqlite3_create_module_v2=i.jd)(e,t,r,_,o),Ko=n._sqlite3_drop_modules=(e,t)=>(Ko=n._sqlite3_drop_modules=i.kd)(e,t),Xo=n._sqlite3_declare_vtab=(e,t)=>(Xo=n._sqlite3_declare_vtab=i.ld)(e,t),Vo=n._sqlite3_vtab_on_conflict=e=>(Vo=n._sqlite3_vtab_on_conflict=i.md)(e),Yo=n._sqlite3_vtab_config=(e,t,r)=>(Yo=n._sqlite3_vtab_config=i.nd)(e,t,r),$o=n._sqlite3_vtab_collation=(e,t)=>($o=n._sqlite3_vtab_collation=i.od)(e,t),Zo=n._sqlite3_vtab_in=(e,t,r)=>(Zo=n._sqlite3_vtab_in=i.pd)(e,t,r),Jo=n._sqlite3_vtab_rhs_value=(e,t,r)=>(Jo=n._sqlite3_vtab_rhs_value=i.qd)(e,t,r),ei=n._sqlite3_vtab_distinct=e=>(ei=n._sqlite3_vtab_distinct=i.rd)(e),ti=n._sqlite3_keyword_name=(e,t,r)=>(ti=n._sqlite3_keyword_name=i.sd)(e,t,r),ri=n._sqlite3_keyword_count=()=>(ri=n._sqlite3_keyword_count=i.td)(),ni=n._sqlite3_keyword_check=(e,t)=>(ni=n._sqlite3_keyword_check=i.ud)(e,t),_i=n._sqlite3_complete=e=>(_i=n._sqlite3_complete=i.vd)(e),si=n._sqlite3_complete16=e=>(si=n._sqlite3_complete16=i.wd)(e),oi=n._sqlite3_libversion=()=>(oi=n._sqlite3_libversion=i.xd)(),ii=n._sqlite3_libversion_number=()=>(ii=n._sqlite3_libversion_number=i.yd)(),ai=n._sqlite3_threadsafe=()=>(ai=n._sqlite3_threadsafe=i.zd)(),li=n._sqlite3_initialize=()=>(li=n._sqlite3_initialize=i.Ad)(),ci=n._sqlite3_shutdown=()=>(ci=n._sqlite3_shutdown=i.Bd)(),ui=n._sqlite3_config=(e,t)=>(ui=n._sqlite3_config=i.Cd)(e,t),fi=n._sqlite3_db_mutex=e=>(fi=n._sqlite3_db_mutex=i.Dd)(e),di=n._sqlite3_db_release_memory=e=>(di=n._sqlite3_db_release_memory=i.Ed)(e),pi=n._sqlite3_db_cacheflush=e=>(pi=n._sqlite3_db_cacheflush=i.Fd)(e),vi=n._sqlite3_db_config=(e,t,r)=>(vi=n._sqlite3_db_config=i.Gd)(e,t,r),mi=n._sqlite3_last_insert_rowid=e=>(mi=n._sqlite3_last_insert_rowid=i.Hd)(e),Ei=n._sqlite3_set_last_insert_rowid=(e,t,r)=>(Ei=n._sqlite3_set_last_insert_rowid=i.Id)(e,t,r),qi=n._sqlite3_changes64=e=>(qi=n._sqlite3_changes64=i.Jd)(e),hi=n._sqlite3_changes=e=>(hi=n._sqlite3_changes=i.Kd)(e),bi=n._sqlite3_total_changes64=e=>(bi=n._sqlite3_total_changes64=i.Ld)(e),Ti=n._sqlite3_total_changes=e=>(Ti=n._sqlite3_total_changes=i.Md)(e),wi=n._sqlite3_txn_state=(e,t)=>(wi=n._sqlite3_txn_state=i.Nd)(e,t),yi=n._sqlite3_close=e=>(yi=n._sqlite3_close=i.Od)(e),Si=n._sqlite3_close_v2=e=>(Si=n._sqlite3_close_v2=i.Pd)(e),gi=n._sqlite3_busy_handler=(e,t,r)=>(gi=n._sqlite3_busy_handler=i.Qd)(e,t,r),Ii=n._sqlite3_progress_handler=(e,t,r,_)=>(Ii=n._sqlite3_progress_handler=i.Rd)(e,t,r,_),Li=n._sqlite3_busy_timeout=(e,t)=>(Li=n._sqlite3_busy_timeout=i.Sd)(e,t),xi=n._sqlite3_interrupt=e=>(xi=n._sqlite3_interrupt=i.Td)(e),Ai=n._sqlite3_is_interrupted=e=>(Ai=n._sqlite3_is_interrupted=i.Ud)(e),Ni=n._sqlite3_create_function=(e,t,r,_,o,a,l,c)=>(Ni=n._sqlite3_create_function=i.Vd)(e,t,r,_,o,a,l,c),Ri=n._sqlite3_create_function_v2=(e,t,r,_,o,a,l,c,E)=>(Ri=n._sqlite3_create_function_v2=i.Wd)(e,t,r,_,o,a,l,c,E),ki=n._sqlite3_create_window_function=(e,t,r,_,o,a,l,c,E,h)=>(ki=n._sqlite3_create_window_function=i.Xd)(e,t,r,_,o,a,l,c,E,h),Oi=n._sqlite3_create_function16=(e,t,r,_,o,a,l,c)=>(Oi=n._sqlite3_create_function16=i.Yd)(e,t,r,_,o,a,l,c),Qi=n._sqlite3_overload_function=(e,t,r)=>(Qi=n._sqlite3_overload_function=i.Zd)(e,t,r),Ci=n._sqlite3_trace_v2=(e,t,r,_)=>(Ci=n._sqlite3_trace_v2=i._d)(e,t,r,_),Fi=n._sqlite3_commit_hook=(e,t,r)=>(Fi=n._sqlite3_commit_hook=i.$d)(e,t,r),Pi=n._sqlite3_update_hook=(e,t,r)=>(Pi=n._sqlite3_update_hook=i.ae)(e,t,r),Di=n._sqlite3_rollback_hook=(e,t,r)=>(Di=n._sqlite3_rollback_hook=i.be)(e,t,r),Mi=n._sqlite3_autovacuum_pages=(e,t,r,_)=>(Mi=n._sqlite3_autovacuum_pages=i.ce)(e,t,r,_),Ui=n._sqlite3_wal_autocheckpoint=(e,t)=>(Ui=n._sqlite3_wal_autocheckpoint=i.de)(e,t),zi=n._sqlite3_wal_hook=(e,t,r)=>(zi=n._sqlite3_wal_hook=i.ee)(e,t,r),Bi=n._sqlite3_wal_checkpoint_v2=(e,t,r,_,o)=>(Bi=n._sqlite3_wal_checkpoint_v2=i.fe)(e,t,r,_,o),Hi=n._sqlite3_wal_checkpoint=(e,t)=>(Hi=n._sqlite3_wal_checkpoint=i.ge)(e,t),Wi=n._sqlite3_error_offset=e=>(Wi=n._sqlite3_error_offset=i.he)(e),ji=n._sqlite3_errmsg16=e=>(ji=n._sqlite3_errmsg16=i.ie)(e),Gi=n._sqlite3_errcode=e=>(Gi=n._sqlite3_errcode=i.je)(e),Ki=n._sqlite3_extended_errcode=e=>(Ki=n._sqlite3_extended_errcode=i.ke)(e),Xi=n._sqlite3_system_errno=e=>(Xi=n._sqlite3_system_errno=i.le)(e),Vi=n._sqlite3_errstr=e=>(Vi=n._sqlite3_errstr=i.me)(e),Yi=n._sqlite3_limit=(e,t,r)=>(Yi=n._sqlite3_limit=i.ne)(e,t,r),$i=n._sqlite3_open=(e,t)=>($i=n._sqlite3_open=i.oe)(e,t),Zi=n._sqlite3_open_v2=(e,t,r,_)=>(Zi=n._sqlite3_open_v2=i.pe)(e,t,r,_),Ji=n._sqlite3_open16=(e,t)=>(Ji=n._sqlite3_open16=i.qe)(e,t),ea=n._sqlite3_create_collation=(e,t,r,_,o)=>(ea=n._sqlite3_create_collation=i.re)(e,t,r,_,o),ta=n._sqlite3_create_collation_v2=(e,t,r,_,o,a)=>(ta=n._sqlite3_create_collation_v2=i.se)(e,t,r,_,o,a),ra=n._sqlite3_create_collation16=(e,t,r,_,o)=>(ra=n._sqlite3_create_collation16=i.te)(e,t,r,_,o),na=n._sqlite3_collation_needed=(e,t,r)=>(na=n._sqlite3_collation_needed=i.ue)(e,t,r),_a=n._sqlite3_collation_needed16=(e,t,r)=>(_a=n._sqlite3_collation_needed16=i.ve)(e,t,r),sa=n._sqlite3_get_clientdata=(e,t)=>(sa=n._sqlite3_get_clientdata=i.we)(e,t),oa=n._sqlite3_set_clientdata=(e,t,r,_)=>(oa=n._sqlite3_set_clientdata=i.xe)(e,t,r,_),ia=n._sqlite3_get_autocommit=e=>(ia=n._sqlite3_get_autocommit=i.ye)(e),aa=n._sqlite3_table_column_metadata=(e,t,r,_,o,a,l,c,E)=>(aa=n._sqlite3_table_column_metadata=i.ze)(e,t,r,_,o,a,l,c,E),la=n._sqlite3_sleep=e=>(la=n._sqlite3_sleep=i.Ae)(e),ca=n._sqlite3_extended_result_codes=(e,t)=>(ca=n._sqlite3_extended_result_codes=i.Be)(e,t),ua=n._sqlite3_file_control=(e,t,r,_)=>(ua=n._sqlite3_file_control=i.Ce)(e,t,r,_),fa=n._sqlite3_test_control=(e,t)=>(fa=n._sqlite3_test_control=i.De)(e,t),da=n._sqlite3_create_filename=(e,t,r,_,o)=>(da=n._sqlite3_create_filename=i.Ee)(e,t,r,_,o),pa=n._sqlite3_free_filename=e=>(pa=n._sqlite3_free_filename=i.Fe)(e),va=n._sqlite3_uri_parameter=(e,t)=>(va=n._sqlite3_uri_parameter=i.Ge)(e,t),ma=n._sqlite3_uri_key=(e,t)=>(ma=n._sqlite3_uri_key=i.He)(e,t),Ea=n._sqlite3_uri_boolean=(e,t,r)=>(Ea=n._sqlite3_uri_boolean=i.Ie)(e,t,r),qa=n._sqlite3_uri_int64=(e,t,r,_)=>(qa=n._sqlite3_uri_int64=i.Je)(e,t,r,_),ha=n._sqlite3_filename_database=e=>(ha=n._sqlite3_filename_database=i.Ke)(e),ba=n._sqlite3_filename_journal=e=>(ba=n._sqlite3_filename_journal=i.Le)(e),Ta=n._sqlite3_filename_wal=e=>(Ta=n._sqlite3_filename_wal=i.Me)(e),wa=n._sqlite3_db_name=(e,t)=>(wa=n._sqlite3_db_name=i.Ne)(e,t),ya=n._sqlite3_db_filename=(e,t)=>(ya=n._sqlite3_db_filename=i.Oe)(e,t),Sa=n._sqlite3_db_readonly=(e,t)=>(Sa=n._sqlite3_db_readonly=i.Pe)(e,t),ga=n._sqlite3_compileoption_used=e=>(ga=n._sqlite3_compileoption_used=i.Qe)(e),Ia=n._sqlite3_compileoption_get=e=>(Ia=n._sqlite3_compileoption_get=i.Re)(e),La=n._sqlite3_sourceid=()=>(La=n._sqlite3_sourceid=i.Se)(),xa=n._malloc=e=>(xa=n._malloc=i.Te)(e),Aa=n._free=e=>(Aa=n._free=i.Ue)(e),Na=n._RegisterExtensionFunctions=e=>(Na=n._RegisterExtensionFunctions=i.Ve)(e),Ra=n._getSqliteFree=()=>(Ra=n._getSqliteFree=i.We)(),ct=n._main=(e,t)=>(ct=n._main=i.Xe)(e,t),ka=n._libauthorizer_set_authorizer=(e,t,r)=>(ka=n._libauthorizer_set_authorizer=i.Ye)(e,t,r),Oa=n._libfunction_create_function=(e,t,r,_,o,a,l,c)=>(Oa=n._libfunction_create_function=i.Ze)(e,t,r,_,o,a,l,c),Qa=n._libprogress_progress_handler=(e,t,r,_)=>(Qa=n._libprogress_progress_handler=i._e)(e,t,r,_),Ca=n._libvfs_vfs_register=(e,t,r,_,o,a)=>(Ca=n._libvfs_vfs_register=i.$e)(e,t,r,_,o,a),ut=(e,t)=>(ut=i.bf)(e,t),ft=()=>(ft=i.cf)(),dt=e=>(dt=i.df)(e),pt=e=>(pt=i.ef)(e),vt=()=>(vt=i.ff)(),Wa=n._sqlite3_version=5472;n.getTempRet0=Dn,n.ccall=Ee,n.cwrap=Pn,n.addFunction=Cn,n.setValue=Ae,n.getValue=$e,n.UTF8ToString=ce,n.stringToUTF8=se,n.lengthBytesUTF8=pe,n.intArrayFromString=Me,n.intArrayToString=Wn,n.AsciiToString=zn,n.UTF16ToString=Bn,n.stringToUTF16=Mn,n.UTF32ToString=Hn,n.stringToUTF32=Un,n.writeArrayToMemory=it;var Re;be=function e(){Re||mt(),Re||(be=e)};function Fa(){var e=ct,t=0,r=0;try{var _=e(t,r);return In(_,!0),_}catch(o){return Ln(o)}}function mt(){if(le>0||(Rt(),le>0))return;function e(){Re||(Re=!0,n.calledRun=!0,!W&&(kt(),Ot(),ie(n),n.onRuntimeInitialized?.(),Et&&Fa(),Qt()))}n.setStatus?(n.setStatus("Running..."),setTimeout(function(){setTimeout(function(){n.setStatus("")},1),e()},1)):e()}if(n.preInit)for(typeof n.preInit=="function"&&(n.preInit=[n.preInit]);n.preInit.length>0;)n.preInit.pop()();var Et=!0;return n.noInitialRun&&(Et=!1),mt(),function(){let e=Object.getPrototypeOf(async function(){}).constructor,t=0;n.set_authorizer=function(r,_,o){t&&(n.deleteCallback(t),n._sqlite3_free(t),t=0),t=n._sqlite3_malloc(4),Ae(t,_ instanceof e?1:0,"i32");let a=Ee("libauthorizer_set_authorizer","number",["number","number","number"],[r,_?1:0,t]);return!a&&_&&n.setCallback(t,(l,c,E,h,g,A)=>_(o,c,E,h,g,A)),a}}(),function(){let e=Object.getPrototypeOf(async function(){}).constructor,t=["xFunc","xStep","xFinal"],r=new Map;n.create_function=function(_,o,a,l,c,E,h,g){let A=n._sqlite3_malloc(4),x={xFunc:E,xStep:h,xFinal:g};Ae(A,t.reduce((b,M,X)=>x[M]instanceof e?b|1<o(a))}}(),function(){let e=["xOpen","xDelete","xAccess","xFullPathname","xRandomness","xSleep","xCurrentTime","xGetLastError","xCurrentTimeInt64","xClose","xRead","xWrite","xTruncate","xSync","xFileSize","xLock","xUnlock","xCheckReservedLock","xFileControl","xSectorSize","xDeviceCharacteristics","xShmMap","xShmLock","xShmBarrier","xShmUnmap"],t=new Map;n.vfs_register=function(r,_){let o=0,a=0;e.forEach((c,E)=>{r[c]&&(o|=1< Date: Mon, 22 Jul 2024 13:30:07 -0400 Subject: [PATCH 06/28] latest --- Cargo.lock | 114 +++++++++++++++------------ Cargo.toml | 2 +- diesel-wasm-sqlite/Cargo.toml | 11 ++- diesel-wasm-sqlite/README.md | 12 +++ diesel-wasm-sqlite/esbuild.js | 4 + diesel-wasm-sqlite/package-lock.json | 15 +++- diesel-wasm-sqlite/package.js | 3 + diesel-wasm-sqlite/package.json | 3 +- diesel-wasm-sqlite/src/lib.rs | 46 +++++++---- diesel-wasm-sqlite/src/package.js | 4 +- diesel-wasm-sqlite/src/utils.rs | 10 +++ diesel-wasm-sqlite/tests/web.rs | 27 +++++++ 12 files changed, 179 insertions(+), 72 deletions(-) create mode 100644 diesel-wasm-sqlite/src/utils.rs create mode 100755 diesel-wasm-sqlite/tests/web.rs diff --git a/Cargo.lock b/Cargo.lock index 025898ae1..d77d862ef 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -43,7 +43,7 @@ version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "cipher", "cpufeatures", ] @@ -326,7 +326,7 @@ checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a" dependencies = [ "addr2line", "cc", - "cfg-if", + "cfg-if 1.0.0", "libc", "miniz_oxide", "object", @@ -547,6 +547,12 @@ dependencies = [ "libc", ] +[[package]] +name = "cfg-if" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" + [[package]] name = "cfg-if" version = "1.0.0" @@ -559,7 +565,7 @@ version = "0.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "cipher", "cpufeatures", ] @@ -756,7 +762,7 @@ version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "wasm-bindgen", ] @@ -766,7 +772,7 @@ version = "1.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94fb8a24a26d37e1ffd45343323dc9fe6654ceea44c12f2fcb3d7ac29e610bc6" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "cpufeatures", "hex", "proptest", @@ -816,7 +822,7 @@ version = "1.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", ] [[package]] @@ -958,7 +964,7 @@ version = "4.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "cpufeatures", "curve25519-dalek-derive", "digest 0.10.7", @@ -1074,14 +1080,17 @@ dependencies = [ [[package]] name = "diesel-wasm-sqlite" -version = "0.1.0" +version = "0.1.1" dependencies = [ + "console_error_panic_hook", "diesel", "getrandom", "log", "rand", "wasm-bindgen", "wasm-bindgen-test", + "web-sys", + "wee_alloc", ] [[package]] @@ -1156,7 +1165,7 @@ version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "dirs-sys-next", ] @@ -1329,7 +1338,7 @@ version = "0.8.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", ] [[package]] @@ -1682,7 +1691,7 @@ version = "2.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "66244a771d9163282646dbeffe0e6eca4dda4146b6498644e678ac6089b11edd" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "const-hex", "dirs", "dunce", @@ -1736,7 +1745,7 @@ version = "2.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cc04871e5ae3aa2952d552dae6b291b3099723bf779a8054281c1366a54613ef" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "js-sys", "log", "serde", @@ -2023,7 +2032,7 @@ version = "0.2.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "js-sys", "libc", "wasi", @@ -2130,7 +2139,7 @@ version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "crunchy", ] @@ -2622,7 +2631,7 @@ version = "0.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "js-sys", "wasm-bindgen", "web-sys", @@ -2731,7 +2740,7 @@ version = "0.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92a55e0ff3b72c262bcf041d9e97f1b84492b68f1c1a384de2323d3dc9403397" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "ecdsa 0.15.1", "elliptic-curve 0.12.3", "once_cell", @@ -2745,7 +2754,7 @@ version = "0.13.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "ecdsa 0.16.9", "elliptic-curve 0.13.8", "once_cell", @@ -2936,7 +2945,7 @@ version = "0.10.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "digest 0.10.7", ] @@ -2946,6 +2955,12 @@ version = "2.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" +[[package]] +name = "memory_units" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8452105ba047068f40ff7093dd1d9da90898e63dd61736462e9cdda6a90ad3c3" + [[package]] name = "migrations_internals" version = "2.2.0" @@ -3036,7 +3051,7 @@ version = "0.11.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4c84490118f2ee2d74570d114f3d0493cbf02790df303d2707606c3e14e07c96" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "downcast", "fragile", "lazy_static", @@ -3051,7 +3066,7 @@ version = "0.11.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "22ce75669015c4f47b289fd4d4f56e894e4c96003ffdf3ac51313126f94c6cbb" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "proc-macro2", "quote", "syn 1.0.109", @@ -3383,7 +3398,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f" dependencies = [ "bitflags 2.6.0", - "cfg-if", + "cfg-if 1.0.0", "foreign-types", "libc", "once_cell", @@ -3517,7 +3532,7 @@ version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "60a2cfe6f0ad2bfc16aefa463b497d5c7a5ecd44a23efa72aa342d90177356dc" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "instant", "libc", "redox_syscall 0.2.16", @@ -3531,7 +3546,7 @@ version = "0.9.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "libc", "redox_syscall 0.5.3", "smallvec", @@ -3849,7 +3864,7 @@ version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "cpufeatures", "opaque-debug", "universal-hash", @@ -4380,7 +4395,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d" dependencies = [ "cc", - "cfg-if", + "cfg-if 1.0.0", "getrandom", "libc", "spin 0.9.8", @@ -4437,7 +4452,7 @@ version = "0.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "290ca1a1c8ca7edb7c3283bd44dc35dd54fdec6253a3912e201ba1072018fca8" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "proc-macro2", "quote", "rustc_version", @@ -4635,7 +4650,7 @@ version = "2.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eca070c12893629e2cc820a9761bedf6ce1dcddc9852984d1dc734b8bd9bd024" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "derive_more", "parity-scale-codec", "scale-info-derive", @@ -4844,7 +4859,7 @@ version = "0.10.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "cpufeatures", "digest 0.10.7", ] @@ -4856,7 +4871,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800" dependencies = [ "block-buffer 0.9.0", - "cfg-if", + "cfg-if 1.0.0", "cpufeatures", "digest 0.9.0", "opaque-debug", @@ -4868,7 +4883,7 @@ version = "0.10.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "cpufeatures", "digest 0.10.7", ] @@ -5238,7 +5253,7 @@ version = "3.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "fastrand", "rustix", "windows-sys 0.52.0", @@ -5270,21 +5285,6 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76" -[[package]] -name = "test-wasm" -version = "0.1.0" -dependencies = [ - "chrono", - "diesel", - "diesel-wasm-sqlite", - "getrandom", - "rand", - "serde", - "wasm-bindgen", - "wasm-bindgen-test", - "web-sys", -] - [[package]] name = "thiserror" version = "1.0.63" @@ -5311,7 +5311,7 @@ version = "1.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "once_cell", ] @@ -6074,7 +6074,7 @@ version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "serde", "serde_json", "wasm-bindgen-macro", @@ -6101,7 +6101,7 @@ version = "0.4.42" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "js-sys", "wasm-bindgen", "web-sys", @@ -6208,6 +6208,18 @@ dependencies = [ "rustls-pki-types", ] +[[package]] +name = "wee_alloc" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbb3b5a6b2bb17cb6ad44a2e68a43e8d2722c997da10e928665c72ec6c0a0b8e" +dependencies = [ + "cfg-if 0.1.10", + "libc", + "memory_units", + "winapi", +] + [[package]] name = "which" version = "4.4.2" @@ -6423,7 +6435,7 @@ version = "0.50.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "windows-sys 0.48.0", ] @@ -6433,7 +6445,7 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a277a57398d4bfa075df44f501a17cfdf8542d224f0d36095a2adc7aee4ef0a5" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", "windows-sys 0.48.0", ] diff --git a/Cargo.toml b/Cargo.toml index 262d5f577..78f19303c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,7 +9,7 @@ members = [ "xmtp_user_preferences", "xmtp_v2", "xmtp_mls", - "xmtp_id", "diesel-wasm-sqlite", "examples/test-wasm", + "xmtp_id", "diesel-wasm-sqlite" ] exclude = [ diff --git a/diesel-wasm-sqlite/Cargo.toml b/diesel-wasm-sqlite/Cargo.toml index c8fba4f7f..48ccd0ccd 100644 --- a/diesel-wasm-sqlite/Cargo.toml +++ b/diesel-wasm-sqlite/Cargo.toml @@ -1,17 +1,26 @@ [package] name = "diesel-wasm-sqlite" -version = "0.1.0" +version = "0.1.1" edition = "2021" [dependencies] diesel = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend", features = ["r2d2", "i-implement-a-third-party-backend-and-opt-into-breaking-changes"] } wasm-bindgen = "0.2" log = "0.4" +rand = "0.8" +getrandom = { version = "0.2", features = ["js"] } +wee_alloc = { version = "0.4.2", optional = true } +console_error_panic_hook = { version = "0.1", optional = true } [dev-dependencies] rand = "0.8" getrandom = { version = "0.2", features = ["js"] } wasm-bindgen-test = "0.3" +web-sys = { version = "0.3", features = ["console"] } + [lib] crate-type = ["cdylib", "rlib"] + +[features] +default = ["console_error_panic_hook"] diff --git a/diesel-wasm-sqlite/README.md b/diesel-wasm-sqlite/README.md index d30161ad3..57e36feb7 100644 --- a/diesel-wasm-sqlite/README.md +++ b/diesel-wasm-sqlite/README.md @@ -1 +1,13 @@ # Custom Diesel Backend for Wasm wa-sqlite + +#### Bundle the javascript in `package.js` to rust + +`npm run esbuild` + +#### Build the JS WASM interface + +`wasm-pack build` + +#### Run the Wasm Tests + +wasm-pack test --safari --headless diff --git a/diesel-wasm-sqlite/esbuild.js b/diesel-wasm-sqlite/esbuild.js index 00164c0c4..d85602232 100644 --- a/diesel-wasm-sqlite/esbuild.js +++ b/diesel-wasm-sqlite/esbuild.js @@ -1,9 +1,13 @@ const esbuild = require("esbuild"); +const { wasmLoader } = require("esbuild-plugin-wasm"); esbuild.build({ entryPoints: ["package.js"], bundle: true, outfile: "src/package.js", + plugins: [ + wasmLoader(), + ], format: "esm", minify: true, }).catch(() => process.exit(1)); diff --git a/diesel-wasm-sqlite/package-lock.json b/diesel-wasm-sqlite/package-lock.json index ab3a8e219..d592b6d5b 100644 --- a/diesel-wasm-sqlite/package-lock.json +++ b/diesel-wasm-sqlite/package-lock.json @@ -10,7 +10,8 @@ "license": "ISC", "dependencies": { "@xmtp/wa-sqlite": "^1.0.1", - "esbuild": "^0.23.0" + "esbuild": "^0.23.0", + "esbuild-plugin-wasm": "^1.1.0" } }, "node_modules/@esbuild/aix-ppc64": { @@ -415,6 +416,18 @@ "@esbuild/win32-ia32": "0.23.0", "@esbuild/win32-x64": "0.23.0" } + }, + "node_modules/esbuild-plugin-wasm": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/esbuild-plugin-wasm/-/esbuild-plugin-wasm-1.1.0.tgz", + "integrity": "sha512-0bQ6+1tUbySSnxzn5jnXHMDvYnT0cN/Wd4Syk8g/sqAIJUg7buTIi22svS3Qz6ssx895NT+TgLPb33xi1OkZig==", + "engines": { + "node": ">=0.10.0" + }, + "funding": { + "type": "individual", + "url": "https://ko-fi.com/tschrock" + } } } } diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index fa23e127f..0f738e93a 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -1,7 +1,10 @@ import * as SQLite from "@xmtp/wa-sqlite"; import initModule from "@xmtp/wa-sqlite/build"; +const module = await initModule(); const sqlite3 = SQLite.Factory(module); +const vfs = await OPFSCoopSyncVFS.create("test", module); +sqlite3.vfs_register(vfs, true); export function sqlite3_result_text(context, value) { sqlite3.result_text(context, value); diff --git a/diesel-wasm-sqlite/package.json b/diesel-wasm-sqlite/package.json index 9709463a6..196f0c535 100644 --- a/diesel-wasm-sqlite/package.json +++ b/diesel-wasm-sqlite/package.json @@ -11,6 +11,7 @@ "license": "ISC", "dependencies": { "@xmtp/wa-sqlite": "^1.0.1", - "esbuild": "^0.23.0" + "esbuild": "^0.23.0", + "esbuild-plugin-wasm": "^1.1.0" } } diff --git a/diesel-wasm-sqlite/src/lib.rs b/diesel-wasm-sqlite/src/lib.rs index 0d3f07afe..668c8ea8e 100644 --- a/diesel-wasm-sqlite/src/lib.rs +++ b/diesel-wasm-sqlite/src/lib.rs @@ -4,6 +4,7 @@ pub mod connection; pub mod ffi; pub mod query_builder; pub mod sqlite_types; +pub mod utils; use diesel::{ connection::{AnsiTransactionManager, Instrumentation, SimpleConnection, TransactionManager}, @@ -11,7 +12,7 @@ use diesel::{ result::QueryResult, Connection, }; -use wasm_bindgen::JsValue; +use wasm_bindgen::{prelude::wasm_bindgen, JsValue}; pub use backend::{SqliteType, WasmSqlite}; @@ -68,6 +69,18 @@ impl Connection for WasmSqliteConnection { } } +#[wasm_bindgen(js_name = establishDbConnection)] +pub fn establish_db_connection() { + let rng: u16 = rand::random(); + let url = format!( + "{}/wasmtest-{}.db3", + std::env::temp_dir().to_str().unwrap(), + rng + ); + let conn = WasmSqliteConnection::establish(&url).unwrap(); + println!("{:?}", conn); +} + impl From for diesel::result::Error { fn from(value: WasmSqliteError) -> diesel::result::Error { log::error!("NOT IMPLEMENTED, {:?}", value); @@ -88,21 +101,24 @@ impl From for WasmSqliteError { } } -#[cfg(test)] -mod test { +/* +mod tests { use super::*; use wasm_bindgen_test::wasm_bindgen_test; + use web_sys::console; wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser); - - #[wasm_bindgen_test] - fn test_establish() { - let rng: u16 = rand::random(); - let url = format!( - "{}/wasmtest-{}.db3", - std::env::temp_dir().to_str().unwrap(), - rng - ); - let mut conn = WasmSqliteConnection::establish(&url).unwrap(); - println!("{:?}", conn); - } + /* + #[wasm_bindgen_test] + fn test_establish() { + let rng: u16 = rand::random(); + let url = format!( + "{}/wasmtest-{}.db3", + std::env::temp_dir().to_str().unwrap(), + rng + ); + let mut conn = WasmSqliteConnection::establish(&url).unwrap(); + println!("{:?}", conn); + } + */ } +*/ diff --git a/diesel-wasm-sqlite/src/package.js b/diesel-wasm-sqlite/src/package.js index a6d80be28..3be63470c 100644 --- a/diesel-wasm-sqlite/src/package.js +++ b/diesel-wasm-sqlite/src/package.js @@ -1,2 +1,2 @@ -var gt=0x7fffffffffffffffn,It=-0x8000000000000000n,Lt=Object.getPrototypeOf(async function(){}).constructor,ue=class extends Error{constructor(p,K){super(p),this.code=K}},Se=!0;function xt(m){let p={};m.retryOps=[];let K=m._getSqliteFree(),n=m._malloc(8),ie=[n,n+4];function te(d){if(typeof d!="string")return 0;let f=new TextEncoder().encode(d),u=m._sqlite3_malloc(f.byteLength+1);return m.HEAPU8.set(f,u),m.HEAPU8[u+f.byteLength]=0,u}function he(d,f){return BigInt(f)<<32n|BigInt(d)&0xffffffffn}let ge=function(){let d=BigInt(Number.MAX_SAFE_INTEGER)>>32n,f=BigInt(Number.MIN_SAFE_INTEGER)>>32n;return function(u,v){return v>d||v2147483647||q<-2147483648)return 25;let w=f(u,v,q);return B(d,w,G.get(u))}}(),p.bind_int64=function(){let d="sqlite3_bind_int64",f=m.cwrap(d,...I("nnnn:n"));return function(u,v,q){if(F(u),q>gt||q>32n,D=f(u,v,Number(w),Number(R));return B(d,D,G.get(u))}}(),p.bind_null=function(){let d="sqlite3_bind_null",f=m.cwrap(d,...I("nn:n"));return function(u,v){F(u);let q=f(u,v);return B(d,q,G.get(u))}}(),p.bind_parameter_name=function(){let f=m.cwrap("sqlite3_bind_parameter_name",...I("n:s"));return function(u,v){return F(u),f(u,v)}}(),p.bind_text=function(){let d="sqlite3_bind_text",f=m.cwrap(d,...I("nnnnn:n"));return function(u,v,q){F(u);let w=te(q),R=f(u,v,w,-1,K);return B(d,R,G.get(u))}}(),p.changes=function(){let f=m.cwrap("sqlite3_changes",...I("n:n"));return function(u){return fe(u),f(u)}}(),p.close=function(){let d="sqlite3_close",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){fe(u);let v=await f(u);return re.delete(u),B(d,v,u)}}(),p.column=function(d,f){F(d);let u=p.column_type(d,f);switch(u){case 4:return p.column_blob(d,f);case 2:return p.column_double(d,f);case 1:let v=p.column_int(d,f),q=m.getTempRet0();return ge(v,q);case 5:return null;case 3:return p.column_text(d,f);default:throw new ue("unknown type",u)}},p.column_blob=function(){let f=m.cwrap("sqlite3_column_blob",...I("nn:n"));return function(u,v){F(u);let q=p.column_bytes(u,v),w=f(u,v);return m.HEAPU8.subarray(w,w+q)}}(),p.column_bytes=function(){let f=m.cwrap("sqlite3_column_bytes",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_count=function(){let f=m.cwrap("sqlite3_column_count",...I("n:n"));return function(u){return F(u),f(u)}}(),p.column_double=function(){let f=m.cwrap("sqlite3_column_double",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_int=function(){let f=m.cwrap("sqlite3_column_int64",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_int64=function(){let f=m.cwrap("sqlite3_column_int64",...I("nn:n"));return function(u,v){F(u);let q=f(u,v),w=m.getTempRet0();return he(q,w)}}(),p.column_name=function(){let f=m.cwrap("sqlite3_column_name",...I("nn:s"));return function(u,v){return F(u),f(u,v)}}(),p.column_names=function(d){let f=[],u=p.column_count(d);for(let v=0;vk(C,m.HEAP32.subarray(Z/4,Z/4+U)):(C,U,Z)=>k(C,m.HEAP32.subarray(Z/4,Z/4+U))}let j=m.create_function(d,f,u,v,q,w&&W(w),R&&W(R),D);return B("sqlite3_create_function",j,d)},p.data_count=function(){let f=m.cwrap("sqlite3_data_count",...I("n:n"));return function(u){return F(u),f(u)}}(),p.exec=async function(d,f,u){for await(let v of p.statements(d,f)){let q;for(;await p.step(v)===100;)if(u){q=q??p.column_names(v);let w=p.row(v);await u(w,q)}}return 0},p.finalize=function(){let f=m.cwrap("sqlite3_finalize",...I("n:n"),{async:Se});return async function(u){let v=await f(u);return G.delete(u),v}}(),p.get_autocommit=function(){let f=m.cwrap("sqlite3_get_autocommit",...I("n:n"));return function(u){return f(u)}}(),p.libversion=function(){let f=m.cwrap("sqlite3_libversion",...I(":s"));return function(){return f()}}(),p.libversion_number=function(){let f=m.cwrap("sqlite3_libversion_number",...I(":n"));return function(){return f()}}(),p.limit=function(){let f=m.cwrap("sqlite3_limit",...I("nnn:n"));return function(u,v,q){return f(u,v,q)}}(),p.open_v2=function(){let d="sqlite3_open_v2",f=m.cwrap(d,...I("snnn:n"),{async:Se});return async function(u,v,q){v=v||6,q=te(q);try{let w=await ae(()=>f(u,ie[0],v,q)),R=m.getValue(ie[0],"*");return re.add(R),m.ccall("RegisterExtensionFunctions","void",["number"],[R]),B(d,w),R}finally{m._sqlite3_free(q)}}}(),p.progress_handler=function(d,f,u,v){fe(d),m.progress_handler(d,f,u,v)},p.reset=function(){let d="sqlite3_reset",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){F(u);let v=await f(u);return B(d,v,G.get(u))}}(),p.result=function(d,f){switch(typeof f){case"number":f===(f|0)?p.result_int(d,f):p.result_double(d,f);break;case"string":p.result_text(d,f);break;default:if(f instanceof Uint8Array||Array.isArray(f))p.result_blob(d,f);else if(f===null)p.result_null(d);else{if(typeof f=="bigint")return p.result_int64(d,f);console.warn("unknown result converted to null",f),p.result_null(d)}break}},p.result_blob=function(){let f=m.cwrap("sqlite3_result_blob",...I("nnnn:n"));return function(u,v){let q=v.byteLength??v.length,w=m._sqlite3_malloc(q);m.HEAPU8.subarray(w).set(v),f(u,w,q,K)}}(),p.result_double=function(){let f=m.cwrap("sqlite3_result_double",...I("nn:n"));return function(u,v){f(u,v)}}(),p.result_int=function(){let f=m.cwrap("sqlite3_result_int",...I("nn:n"));return function(u,v){f(u,v)}}(),p.result_int64=function(){let f=m.cwrap("sqlite3_result_int64",...I("nnn:n"));return function(u,v){if(v>gt||v>32n;f(u,Number(q),Number(w))}}(),p.result_null=function(){let f=m.cwrap("sqlite3_result_null",...I("n:n"));return function(u){f(u)}}(),p.result_text=function(){let f=m.cwrap("sqlite3_result_text",...I("nnnn:n"));return function(u,v){let q=te(v);f(u,q,-1,K)}}(),p.row=function(d){let f=[],u=p.data_count(d);for(let v=0;vR(v(D,W,j,k,C,U)):(D,W,j,k,C,U)=>R(v(D,W,j,k,C,U))}let w=m.set_authorizer(d,q(f),u);return B("sqlite3_set_authorizer",w,d)},p.sql=function(){let f=m.cwrap("sqlite3_sql",...I("n:s"));return function(u){return F(u),f(u)}}(),p.statements=function(d,f,u={}){let v=m.cwrap("sqlite3_prepare_v3","number",["number","number","number","number","number","number"],{async:!0});return async function*(){let q=[];try{let U=function(){C&&!u.unscoped&&p.finalize(C),C=0},w=new TextEncoder().encode(f),R=w.byteLength-w.byteLength%4+12,D=m._sqlite3_malloc(R),W=D+w.byteLength+1;q.push(()=>m._sqlite3_free(D)),m.HEAPU8.set(w,D),m.HEAPU8[W-1]=0;let j=D+R-8,k=D+R-4,C;q.push(U),m.setValue(k,D,"*");do{U();let Z=m.getValue(k,"*"),y=await ae(()=>v(d,Z,W-k,u.flags||0,j,k));y!==0&&B("sqlite3_prepare_v3",y,d),C=m.getValue(j,"*"),C&&(G.set(C,d),yield C)}while(C)}finally{for(;q.length;)q.pop()()}}()},p.step=function(){let d="sqlite3_step",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){F(u);let v=await ae(()=>f(u));return B(d,v,G.get(u),[100,101])}}(),p.value=function(d){let f=p.value_type(d);switch(f){case 4:return p.value_blob(d);case 2:return p.value_double(d);case 1:let u=p.value_int(d),v=m.getTempRet0();return ge(u,v);case 5:return null;case 3:return p.value_text(d);default:throw new ue("unknown type",f)}},p.value_blob=function(){let f=m.cwrap("sqlite3_value_blob",...I("n:n"));return function(u){let v=p.value_bytes(u),q=f(u);return m.HEAPU8.subarray(q,q+v)}}(),p.value_bytes=function(){let f=m.cwrap("sqlite3_value_bytes",...I("n:n"));return function(u){return f(u)}}(),p.value_double=function(){let f=m.cwrap("sqlite3_value_double",...I("n:n"));return function(u){return f(u)}}(),p.value_int=function(){let f=m.cwrap("sqlite3_value_int64",...I("n:n"));return function(u){return f(u)}}(),p.value_int64=function(){let f=m.cwrap("sqlite3_value_int64",...I("n:n"));return function(u){let v=f(u),q=m.getTempRet0();return he(v,q)}}(),p.value_text=function(){let f=m.cwrap("sqlite3_value_text",...I("n:s"));return function(u){return f(u)}}(),p.value_type=function(){let f=m.cwrap("sqlite3_value_type",...I("n:n"));return function(u){return f(u)}}(),p.vfs_register=function(d,f){let u=m.vfs_register(d,f);return B("sqlite3_vfs_register",u)};function B(d,f,u=null,v=[0]){if(v.includes(f))return f;let q=u?m.ccall("sqlite3_errmsg","string",["number"],[u]):d;throw new ue(q,f)}async function ae(d){let f;do m.retryOps.length&&(await Promise.all(m.retryOps),m.retryOps=[]),f=await d();while(f&&m.retryOps.length);return f}return p}function I(m){let p=[],K=m.match(/([ns@]*):([nsv@])/);switch(K[2]){case"n":p.push("number");break;case"s":p.push("string");break;case"v":p.push(null);break}let n=[];for(let ie of K[1])switch(ie){case"n":n.push("number");break;case"s":n.push("string");break}return p.push(n),p}var Ga=(()=>{var m=import.meta.url;return function(p={}){var K,n=p,ie,te,he=new Promise((e,t)=>{ie=e,te=t}),ge=typeof window=="object",re=typeof importScripts=="function",fe=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string",G=Object.assign({},n),F=[],B="./this.program",ae=(e,t)=>{throw t},d="";function f(e){return n.locateFile?n.locateFile(e,d):d+e}var u,v;(ge||re)&&(re?d=self.location.href:typeof document<"u"&&document.currentScript&&(d=document.currentScript.src),m&&(d=m),d.startsWith("blob:")?d="":d=d.substr(0,d.replace(/[?#].*/,"").lastIndexOf("/")+1),re&&(v=e=>{var t=new XMLHttpRequest;return t.open("GET",e,!1),t.responseType="arraybuffer",t.send(null),new Uint8Array(t.response)}),u=e=>fetch(e,{credentials:"same-origin"}).then(t=>t.ok?t.arrayBuffer():Promise.reject(new Error(t.status+" : "+t.url))));var q=n.print||console.log.bind(console),w=n.printErr||console.error.bind(console);Object.assign(n,G),G=null,n.arguments&&(F=n.arguments),n.thisProgram&&(B=n.thisProgram),n.quit&&(ae=n.quit);var R;n.wasmBinary&&(R=n.wasmBinary);var D,W=!1,j,k,C,U,Z,y,z,Oe,Qe;function He(){var e=D.buffer;n.HEAP8=k=new Int8Array(e),n.HEAP16=U=new Int16Array(e),n.HEAPU8=C=new Uint8Array(e),n.HEAPU16=Z=new Uint16Array(e),n.HEAP32=y=new Int32Array(e),n.HEAPU32=z=new Uint32Array(e),n.HEAPF32=Oe=new Float32Array(e),n.HEAPF64=Qe=new Float64Array(e)}var We=[],je=[],At=[],Ge=[],Nt=!1;function Rt(){if(n.preRun)for(typeof n.preRun=="function"&&(n.preRun=[n.preRun]);n.preRun.length;)Ct(n.preRun.shift());xe(We)}function kt(){Nt=!0,!n.noFSInit&&!s.init.initialized&&s.init(),s.ignorePermissions=!1,_e.init(),xe(je)}function Ot(){xe(At)}function Qt(){if(n.postRun)for(typeof n.postRun=="function"&&(n.postRun=[n.postRun]);n.postRun.length;)Pt(n.postRun.shift());xe(Ge)}function Ct(e){We.unshift(e)}function Ft(e){je.unshift(e)}function Pt(e){Ge.unshift(e)}var le=0,Ce=null,be=null;function Ha(e){return e}function Fe(e){le++,n.monitorRunDependencies?.(le)}function Ie(e){if(le--,n.monitorRunDependencies?.(le),le==0&&(Ce!==null&&(clearInterval(Ce),Ce=null),be)){var t=be;be=null,t()}}function ne(e){n.onAbort?.(e),e="Aborted("+e+")",w(e),W=!0,j=1,e+=". Build with -sASSERTIONS for more info.";var t=new WebAssembly.RuntimeError(e);throw te(t),t}var Dt="data:application/octet-stream;base64,",Ke=e=>e.startsWith(Dt);function Mt(){if(n.locateFile){var e="wa-sqlite.wasm";return Ke(e)?e:f(e)}return new URL("wa-sqlite.wasm",import.meta.url).href}var Le;function Xe(e){if(e==Le&&R)return new Uint8Array(R);if(v)return v(e);throw"both async and sync fetching of the wasm failed"}function Ut(e){return R?Promise.resolve().then(()=>Xe(e)):u(e).then(t=>new Uint8Array(t),()=>Xe(e))}function Ve(e,t,r){return Ut(e).then(_=>WebAssembly.instantiate(_,t)).then(r,_=>{w(`failed to asynchronously prepare wasm: ${_}`),ne(_)})}function zt(e,t,r,_){return!e&&typeof WebAssembly.instantiateStreaming=="function"&&!Ke(t)&&typeof fetch=="function"?fetch(t,{credentials:"same-origin"}).then(o=>{var a=WebAssembly.instantiateStreaming(o,r);return a.then(_,function(l){return w(`wasm streaming compile failed: ${l}`),w("falling back to ArrayBuffer instantiation"),Ve(t,r,_)})}):Ve(t,r,_)}function Bt(){return{a:jn}}function Ht(){var e=Bt();function t(_,o){return i=_.exports,D=i.ja,He(),ve=i.af,Ft(i.ka),Ie("wasm-instantiate"),i}Fe("wasm-instantiate");function r(_){t(_.instance)}if(n.instantiateWasm)try{return n.instantiateWasm(e,t)}catch(_){w(`Module.instantiateWasm callback failed with error: ${_}`),te(_)}return Le||(Le=Mt()),zt(R,Le,e,r).catch(te),{}}var S,P;function Ye(e){this.name="ExitStatus",this.message=`Program terminated with exit(${e})`,this.status=e}var xe=e=>{for(;e.length>0;)e.shift()(n)};function $e(e,t="i8"){switch(t.endsWith("*")&&(t="*"),t){case"i1":return k[e];case"i8":return k[e];case"i16":return U[e>>1];case"i32":return y[e>>2];case"i64":ne("to do getValue(i64) use WASM_BIGINT");case"float":return Oe[e>>2];case"double":return Qe[e>>3];case"*":return z[e>>2];default:ne(`invalid type for getValue: ${t}`)}}var Wt=n.noExitRuntime||!0;function Ae(e,t,r="i8"){switch(r.endsWith("*")&&(r="*"),r){case"i1":k[e]=t;break;case"i8":k[e]=t;break;case"i16":U[e>>1]=t;break;case"i32":y[e>>2]=t;break;case"i64":ne("to do setValue(i64) use WASM_BIGINT");case"float":Oe[e>>2]=t;break;case"double":Qe[e>>3]=t;break;case"*":z[e>>2]=t;break;default:ne(`invalid type for setValue: ${r}`)}}var jt=e=>dt(e),Gt=()=>vt(),Ze=typeof TextDecoder<"u"?new TextDecoder:void 0,de=(e,t,r)=>{for(var _=t+r,o=t;e[o]&&!(o>=_);)++o;if(o-t>16&&e.buffer&&Ze)return Ze.decode(e.subarray(t,o));for(var a="";t>10,56320|h&1023)}}return a},ce=(e,t)=>e?de(C,e,t):"",Kt=(e,t,r,_)=>{ne(`Assertion failed: ${ce(e)}, at: `+[t?ce(t):"unknown filename",r,_?ce(_):"unknown function"])},Q={isAbs:e=>e.charAt(0)==="/",splitPath:e=>{var t=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return t.exec(e).slice(1)},normalizeArray:(e,t)=>{for(var r=0,_=e.length-1;_>=0;_--){var o=e[_];o==="."?e.splice(_,1):o===".."?(e.splice(_,1),r++):r&&(e.splice(_,1),r--)}if(t)for(;r;r--)e.unshift("..");return e},normalize:e=>{var t=Q.isAbs(e),r=e.substr(-1)==="/";return e=Q.normalizeArray(e.split("/").filter(_=>!!_),!t).join("/"),!e&&!t&&(e="."),e&&r&&(e+="/"),(t?"/":"")+e},dirname:e=>{var t=Q.splitPath(e),r=t[0],_=t[1];return!r&&!_?".":(_&&(_=_.substr(0,_.length-1)),r+_)},basename:e=>{if(e==="/")return"/";e=Q.normalize(e),e=e.replace(/\/$/,"");var t=e.lastIndexOf("/");return t===-1?e:e.substr(t+1)},join:(...e)=>Q.normalize(e.join("/")),join2:(e,t)=>Q.normalize(e+"/"+t)},Xt=()=>{if(typeof crypto=="object"&&typeof crypto.getRandomValues=="function")return e=>crypto.getRandomValues(e);ne("initRandomDevice")},Je=e=>(Je=Xt())(e),ee={resolve:(...e)=>{for(var t="",r=!1,_=e.length-1;_>=-1&&!r;_--){var o=_>=0?e[_]:s.cwd();if(typeof o!="string")throw new TypeError("Arguments to path.resolve must be strings");if(!o)return"";t=o+"/"+t,r=Q.isAbs(o)}return t=Q.normalizeArray(t.split("/").filter(a=>!!a),!r).join("/"),(r?"/":"")+t||"."},relative:(e,t)=>{e=ee.resolve(e).substr(1),t=ee.resolve(t).substr(1);function r(h){for(var g=0;g=0&&h[A]==="";A--);return g>A?[]:h.slice(g,A-g+1)}for(var _=r(e.split("/")),o=r(t.split("/")),a=Math.min(_.length,o.length),l=a,c=0;c{for(var t=0,r=0;r=55296&&_<=57343?(t+=4,++r):t+=3}return t},De=(e,t,r,_)=>{if(!(_>0))return 0;for(var o=r,a=r+_-1,l=0;l=55296&&c<=57343){var E=e.charCodeAt(++l);c=65536+((c&1023)<<10)|E&1023}if(c<=127){if(r>=a)break;t[r++]=c}else if(c<=2047){if(r+1>=a)break;t[r++]=192|c>>6,t[r++]=128|c&63}else if(c<=65535){if(r+2>=a)break;t[r++]=224|c>>12,t[r++]=128|c>>6&63,t[r++]=128|c&63}else{if(r+3>=a)break;t[r++]=240|c>>18,t[r++]=128|c>>12&63,t[r++]=128|c>>6&63,t[r++]=128|c&63}}return t[r]=0,r-o};function Me(e,t,r){var _=r>0?r:pe(e)+1,o=new Array(_),a=De(e,o,0,o.length);return t&&(o.length=a),o}var Vt=()=>{if(!Pe.length){var e=null;if(typeof window<"u"&&typeof window.prompt=="function"&&(e=window.prompt("Input: "),e!==null&&(e+=` -`)),!e)return null;Pe=Me(e,!0)}return Pe.shift()},_e={ttys:[],init(){},shutdown(){},register(e,t){_e.ttys[e]={input:[],output:[],ops:t},s.registerDevice(e,_e.stream_ops)},stream_ops:{open(e){var t=_e.ttys[e.node.rdev];if(!t)throw new s.ErrnoError(43);e.tty=t,e.seekable=!1},close(e){e.tty.ops.fsync(e.tty)},fsync(e){e.tty.ops.fsync(e.tty)},read(e,t,r,_,o){if(!e.tty||!e.tty.ops.get_char)throw new s.ErrnoError(60);for(var a=0,l=0;l<_;l++){var c;try{c=e.tty.ops.get_char(e.tty)}catch{throw new s.ErrnoError(29)}if(c===void 0&&a===0)throw new s.ErrnoError(6);if(c==null)break;a++,t[r+l]=c}return a&&(e.node.timestamp=Date.now()),a},write(e,t,r,_,o){if(!e.tty||!e.tty.ops.put_char)throw new s.ErrnoError(60);try{for(var a=0;a<_;a++)e.tty.ops.put_char(e.tty,t[r+a])}catch{throw new s.ErrnoError(29)}return _&&(e.node.timestamp=Date.now()),a}},default_tty_ops:{get_char(e){return Vt()},put_char(e,t){t===null||t===10?(q(de(e.output,0)),e.output=[]):t!=0&&e.output.push(t)},fsync(e){e.output&&e.output.length>0&&(q(de(e.output,0)),e.output=[])},ioctl_tcgets(e){return{c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(e,t,r){return 0},ioctl_tiocgwinsz(e){return[24,80]}},default_tty1_ops:{put_char(e,t){t===null||t===10?(w(de(e.output,0)),e.output=[]):t!=0&&e.output.push(t)},fsync(e){e.output&&e.output.length>0&&(w(de(e.output,0)),e.output=[])}}},Yt=(e,t)=>(C.fill(0,e,e+t),e),$t=(e,t)=>Math.ceil(e/t)*t,et=e=>{e=$t(e,65536);var t=ut(65536,e);return t?Yt(t,e):0},L={ops_table:null,mount(e){return L.createNode(null,"/",16895,0)},createNode(e,t,r,_){if(s.isBlkdev(r)||s.isFIFO(r))throw new s.ErrnoError(63);L.ops_table||={dir:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr,lookup:L.node_ops.lookup,mknod:L.node_ops.mknod,rename:L.node_ops.rename,unlink:L.node_ops.unlink,rmdir:L.node_ops.rmdir,readdir:L.node_ops.readdir,symlink:L.node_ops.symlink},stream:{llseek:L.stream_ops.llseek}},file:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr},stream:{llseek:L.stream_ops.llseek,read:L.stream_ops.read,write:L.stream_ops.write,allocate:L.stream_ops.allocate,mmap:L.stream_ops.mmap,msync:L.stream_ops.msync}},link:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr,readlink:L.node_ops.readlink},stream:{}},chrdev:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr},stream:s.chrdev_stream_ops}};var o=s.createNode(e,t,r,_);return s.isDir(o.mode)?(o.node_ops=L.ops_table.dir.node,o.stream_ops=L.ops_table.dir.stream,o.contents={}):s.isFile(o.mode)?(o.node_ops=L.ops_table.file.node,o.stream_ops=L.ops_table.file.stream,o.usedBytes=0,o.contents=null):s.isLink(o.mode)?(o.node_ops=L.ops_table.link.node,o.stream_ops=L.ops_table.link.stream):s.isChrdev(o.mode)&&(o.node_ops=L.ops_table.chrdev.node,o.stream_ops=L.ops_table.chrdev.stream),o.timestamp=Date.now(),e&&(e.contents[t]=o,e.timestamp=o.timestamp),o},getFileDataAsTypedArray(e){return e.contents?e.contents.subarray?e.contents.subarray(0,e.usedBytes):new Uint8Array(e.contents):new Uint8Array(0)},expandFileStorage(e,t){var r=e.contents?e.contents.length:0;if(!(r>=t)){var _=1024*1024;t=Math.max(t,r*(r<_?2:1.125)>>>0),r!=0&&(t=Math.max(t,256));var o=e.contents;e.contents=new Uint8Array(t),e.usedBytes>0&&e.contents.set(o.subarray(0,e.usedBytes),0)}},resizeFileStorage(e,t){if(e.usedBytes!=t)if(t==0)e.contents=null,e.usedBytes=0;else{var r=e.contents;e.contents=new Uint8Array(t),r&&e.contents.set(r.subarray(0,Math.min(t,e.usedBytes))),e.usedBytes=t}},node_ops:{getattr(e){var t={};return t.dev=s.isChrdev(e.mode)?e.id:1,t.ino=e.id,t.mode=e.mode,t.nlink=1,t.uid=0,t.gid=0,t.rdev=e.rdev,s.isDir(e.mode)?t.size=4096:s.isFile(e.mode)?t.size=e.usedBytes:s.isLink(e.mode)?t.size=e.link.length:t.size=0,t.atime=new Date(e.timestamp),t.mtime=new Date(e.timestamp),t.ctime=new Date(e.timestamp),t.blksize=4096,t.blocks=Math.ceil(t.size/t.blksize),t},setattr(e,t){t.mode!==void 0&&(e.mode=t.mode),t.timestamp!==void 0&&(e.timestamp=t.timestamp),t.size!==void 0&&L.resizeFileStorage(e,t.size)},lookup(e,t){throw s.genericErrors[44]},mknod(e,t,r,_){return L.createNode(e,t,r,_)},rename(e,t,r){if(s.isDir(e.mode)){var _;try{_=s.lookupNode(t,r)}catch{}if(_)for(var o in _.contents)throw new s.ErrnoError(55)}delete e.parent.contents[e.name],e.parent.timestamp=Date.now(),e.name=r,t.contents[r]=e,t.timestamp=e.parent.timestamp},unlink(e,t){delete e.contents[t],e.timestamp=Date.now()},rmdir(e,t){var r=s.lookupNode(e,t);for(var _ in r.contents)throw new s.ErrnoError(55);delete e.contents[t],e.timestamp=Date.now()},readdir(e){var t=[".",".."];for(var r of Object.keys(e.contents))t.push(r);return t},symlink(e,t,r){var _=L.createNode(e,t,41471,0);return _.link=r,_},readlink(e){if(!s.isLink(e.mode))throw new s.ErrnoError(28);return e.link}},stream_ops:{read(e,t,r,_,o){var a=e.node.contents;if(o>=e.node.usedBytes)return 0;var l=Math.min(e.node.usedBytes-o,_);if(l>8&&a.subarray)t.set(a.subarray(o,o+l),r);else for(var c=0;c0||r+t{var o=_?"":`al ${e}`;u(e).then(a=>{t(new Uint8Array(a)),o&&Ie(o)},a=>{if(r)r();else throw`Loading data file "${e}" failed.`}),o&&Fe(o)},Jt=(e,t,r,_,o,a)=>{s.createDataFile(e,t,r,_,o,a)},er=n.preloadPlugins||[],tr=(e,t,r,_)=>{typeof Browser<"u"&&Browser.init();var o=!1;return er.forEach(a=>{o||a.canHandle(t)&&(a.handle(e,t,r,_),o=!0)}),o},rr=(e,t,r,_,o,a,l,c,E,h)=>{var g=t?ee.resolve(Q.join2(e,t)):e,A=`cp ${g}`;function x(T){function b(M){h?.(),c||Jt(e,t,M,_,o,E),a?.(),Ie(A)}tr(T,g,b,()=>{l?.(),Ie(A)})||b(T)}Fe(A),typeof r=="string"?Zt(r,x,l):x(r)},nr=e=>{var t={r:0,"r+":2,w:577,"w+":578,a:1089,"a+":1090},r=t[e];if(typeof r>"u")throw new Error(`Unknown file open mode: ${e}`);return r},Ue=(e,t)=>{var r=0;return e&&(r|=365),t&&(r|=146),r},s={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:!1,ignorePermissions:!0,ErrnoError:class{constructor(e){this.name="ErrnoError",this.errno=e}},genericErrors:{},filesystems:null,syncFSRequests:0,FSStream:class{constructor(){this.shared={}}get object(){return this.node}set object(e){this.node=e}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(e){this.shared.flags=e}get position(){return this.shared.position}set position(e){this.shared.position=e}},FSNode:class{constructor(e,t,r,_){e||(e=this),this.parent=e,this.mount=e.mount,this.mounted=null,this.id=s.nextInode++,this.name=t,this.mode=r,this.node_ops={},this.stream_ops={},this.rdev=_,this.readMode=365,this.writeMode=146}get read(){return(this.mode&this.readMode)===this.readMode}set read(e){e?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(e){e?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return s.isDir(this.mode)}get isDevice(){return s.isChrdev(this.mode)}},lookupPath(e,t={}){if(e=ee.resolve(e),!e)return{path:"",node:null};var r={follow_mount:!0,recurse_count:0};if(t=Object.assign(r,t),t.recurse_count>8)throw new s.ErrnoError(32);for(var _=e.split("/").filter(A=>!!A),o=s.root,a="/",l=0;l<_.length;l++){var c=l===_.length-1;if(c&&t.parent)break;if(o=s.lookupNode(o,_[l]),a=Q.join2(a,_[l]),s.isMountpoint(o)&&(!c||c&&t.follow_mount)&&(o=o.mounted.root),!c||t.follow)for(var E=0;s.isLink(o.mode);){var h=s.readlink(a);a=ee.resolve(Q.dirname(a),h);var g=s.lookupPath(a,{recurse_count:t.recurse_count+1});if(o=g.node,E++>40)throw new s.ErrnoError(32)}}return{path:a,node:o}},getPath(e){for(var t;;){if(s.isRoot(e)){var r=e.mount.mountpoint;return t?r[r.length-1]!=="/"?`${r}/${t}`:r+t:r}t=t?`${e.name}/${t}`:e.name,e=e.parent}},hashName(e,t){for(var r=0,_=0;_>>0)%s.nameTable.length},hashAddNode(e){var t=s.hashName(e.parent.id,e.name);e.name_next=s.nameTable[t],s.nameTable[t]=e},hashRemoveNode(e){var t=s.hashName(e.parent.id,e.name);if(s.nameTable[t]===e)s.nameTable[t]=e.name_next;else for(var r=s.nameTable[t];r;){if(r.name_next===e){r.name_next=e.name_next;break}r=r.name_next}},lookupNode(e,t){var r=s.mayLookup(e);if(r)throw new s.ErrnoError(r);for(var _=s.hashName(e.id,t),o=s.nameTable[_];o;o=o.name_next){var a=o.name;if(o.parent.id===e.id&&a===t)return o}return s.lookup(e,t)},createNode(e,t,r,_){var o=new s.FSNode(e,t,r,_);return s.hashAddNode(o),o},destroyNode(e){s.hashRemoveNode(e)},isRoot(e){return e===e.parent},isMountpoint(e){return!!e.mounted},isFile(e){return(e&61440)===32768},isDir(e){return(e&61440)===16384},isLink(e){return(e&61440)===40960},isChrdev(e){return(e&61440)===8192},isBlkdev(e){return(e&61440)===24576},isFIFO(e){return(e&61440)===4096},isSocket(e){return(e&49152)===49152},flagsToPermissionString(e){var t=["r","w","rw"][e&3];return e&512&&(t+="w"),t},nodePermissions(e,t){return s.ignorePermissions?0:t.includes("r")&&!(e.mode&292)||t.includes("w")&&!(e.mode&146)||t.includes("x")&&!(e.mode&73)?2:0},mayLookup(e){if(!s.isDir(e.mode))return 54;var t=s.nodePermissions(e,"x");return t||(e.node_ops.lookup?0:2)},mayCreate(e,t){try{var r=s.lookupNode(e,t);return 20}catch{}return s.nodePermissions(e,"wx")},mayDelete(e,t,r){var _;try{_=s.lookupNode(e,t)}catch(a){return a.errno}var o=s.nodePermissions(e,"wx");if(o)return o;if(r){if(!s.isDir(_.mode))return 54;if(s.isRoot(_)||s.getPath(_)===s.cwd())return 10}else if(s.isDir(_.mode))return 31;return 0},mayOpen(e,t){return e?s.isLink(e.mode)?32:s.isDir(e.mode)&&(s.flagsToPermissionString(t)!=="r"||t&512)?31:s.nodePermissions(e,s.flagsToPermissionString(t)):44},MAX_OPEN_FDS:4096,nextfd(){for(var e=0;e<=s.MAX_OPEN_FDS;e++)if(!s.streams[e])return e;throw new s.ErrnoError(33)},getStreamChecked(e){var t=s.getStream(e);if(!t)throw new s.ErrnoError(8);return t},getStream:e=>s.streams[e],createStream(e,t=-1){return e=Object.assign(new s.FSStream,e),t==-1&&(t=s.nextfd()),e.fd=t,s.streams[t]=e,e},closeStream(e){s.streams[e]=null},dupStream(e,t=-1){var r=s.createStream(e,t);return r.stream_ops?.dup?.(r),r},chrdev_stream_ops:{open(e){var t=s.getDevice(e.node.rdev);e.stream_ops=t.stream_ops,e.stream_ops.open?.(e)},llseek(){throw new s.ErrnoError(70)}},major:e=>e>>8,minor:e=>e&255,makedev:(e,t)=>e<<8|t,registerDevice(e,t){s.devices[e]={stream_ops:t}},getDevice:e=>s.devices[e],getMounts(e){for(var t=[],r=[e];r.length;){var _=r.pop();t.push(_),r.push(..._.mounts)}return t},syncfs(e,t){typeof e=="function"&&(t=e,e=!1),s.syncFSRequests++,s.syncFSRequests>1&&w(`warning: ${s.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);var r=s.getMounts(s.root.mount),_=0;function o(l){return s.syncFSRequests--,t(l)}function a(l){if(l)return a.errored?void 0:(a.errored=!0,o(l));++_>=r.length&&o(null)}r.forEach(l=>{if(!l.type.syncfs)return a(null);l.type.syncfs(l,e,a)})},mount(e,t,r){var _=r==="/",o=!r,a;if(_&&s.root)throw new s.ErrnoError(10);if(!_&&!o){var l=s.lookupPath(r,{follow_mount:!1});if(r=l.path,a=l.node,s.isMountpoint(a))throw new s.ErrnoError(10);if(!s.isDir(a.mode))throw new s.ErrnoError(54)}var c={type:e,opts:t,mountpoint:r,mounts:[]},E=e.mount(c);return E.mount=c,c.root=E,_?s.root=E:a&&(a.mounted=c,a.mount&&a.mount.mounts.push(c)),E},unmount(e){var t=s.lookupPath(e,{follow_mount:!1});if(!s.isMountpoint(t.node))throw new s.ErrnoError(28);var r=t.node,_=r.mounted,o=s.getMounts(_);Object.keys(s.nameTable).forEach(l=>{for(var c=s.nameTable[l];c;){var E=c.name_next;o.includes(c.mount)&&s.destroyNode(c),c=E}}),r.mounted=null;var a=r.mount.mounts.indexOf(_);r.mount.mounts.splice(a,1)},lookup(e,t){return e.node_ops.lookup(e,t)},mknod(e,t,r){var _=s.lookupPath(e,{parent:!0}),o=_.node,a=Q.basename(e);if(!a||a==="."||a==="..")throw new s.ErrnoError(28);var l=s.mayCreate(o,a);if(l)throw new s.ErrnoError(l);if(!o.node_ops.mknod)throw new s.ErrnoError(63);return o.node_ops.mknod(o,a,t,r)},create(e,t){return t=t!==void 0?t:438,t&=4095,t|=32768,s.mknod(e,t,0)},mkdir(e,t){return t=t!==void 0?t:511,t&=1023,t|=16384,s.mknod(e,t,0)},mkdirTree(e,t){for(var r=e.split("/"),_="",o=0;o"u"&&(r=t,t=438),t|=8192,s.mknod(e,t,r)},symlink(e,t){if(!ee.resolve(e))throw new s.ErrnoError(44);var r=s.lookupPath(t,{parent:!0}),_=r.node;if(!_)throw new s.ErrnoError(44);var o=Q.basename(t),a=s.mayCreate(_,o);if(a)throw new s.ErrnoError(a);if(!_.node_ops.symlink)throw new s.ErrnoError(63);return _.node_ops.symlink(_,o,e)},rename(e,t){var r=Q.dirname(e),_=Q.dirname(t),o=Q.basename(e),a=Q.basename(t),l,c,E;if(l=s.lookupPath(e,{parent:!0}),c=l.node,l=s.lookupPath(t,{parent:!0}),E=l.node,!c||!E)throw new s.ErrnoError(44);if(c.mount!==E.mount)throw new s.ErrnoError(75);var h=s.lookupNode(c,o),g=ee.relative(e,_);if(g.charAt(0)!==".")throw new s.ErrnoError(28);if(g=ee.relative(t,r),g.charAt(0)!==".")throw new s.ErrnoError(55);var A;try{A=s.lookupNode(E,a)}catch{}if(h!==A){var x=s.isDir(h.mode),T=s.mayDelete(c,o,x);if(T)throw new s.ErrnoError(T);if(T=A?s.mayDelete(E,a,x):s.mayCreate(E,a),T)throw new s.ErrnoError(T);if(!c.node_ops.rename)throw new s.ErrnoError(63);if(s.isMountpoint(h)||A&&s.isMountpoint(A))throw new s.ErrnoError(10);if(E!==c&&(T=s.nodePermissions(c,"w"),T))throw new s.ErrnoError(T);s.hashRemoveNode(h);try{c.node_ops.rename(h,E,a),h.parent=E}catch(b){throw b}finally{s.hashAddNode(h)}}},rmdir(e){var t=s.lookupPath(e,{parent:!0}),r=t.node,_=Q.basename(e),o=s.lookupNode(r,_),a=s.mayDelete(r,_,!0);if(a)throw new s.ErrnoError(a);if(!r.node_ops.rmdir)throw new s.ErrnoError(63);if(s.isMountpoint(o))throw new s.ErrnoError(10);r.node_ops.rmdir(r,_),s.destroyNode(o)},readdir(e){var t=s.lookupPath(e,{follow:!0}),r=t.node;if(!r.node_ops.readdir)throw new s.ErrnoError(54);return r.node_ops.readdir(r)},unlink(e){var t=s.lookupPath(e,{parent:!0}),r=t.node;if(!r)throw new s.ErrnoError(44);var _=Q.basename(e),o=s.lookupNode(r,_),a=s.mayDelete(r,_,!1);if(a)throw new s.ErrnoError(a);if(!r.node_ops.unlink)throw new s.ErrnoError(63);if(s.isMountpoint(o))throw new s.ErrnoError(10);r.node_ops.unlink(r,_),s.destroyNode(o)},readlink(e){var t=s.lookupPath(e),r=t.node;if(!r)throw new s.ErrnoError(44);if(!r.node_ops.readlink)throw new s.ErrnoError(28);return ee.resolve(s.getPath(r.parent),r.node_ops.readlink(r))},stat(e,t){var r=s.lookupPath(e,{follow:!t}),_=r.node;if(!_)throw new s.ErrnoError(44);if(!_.node_ops.getattr)throw new s.ErrnoError(63);return _.node_ops.getattr(_)},lstat(e){return s.stat(e,!0)},chmod(e,t,r){var _;if(typeof e=="string"){var o=s.lookupPath(e,{follow:!r});_=o.node}else _=e;if(!_.node_ops.setattr)throw new s.ErrnoError(63);_.node_ops.setattr(_,{mode:t&4095|_.mode&-4096,timestamp:Date.now()})},lchmod(e,t){s.chmod(e,t,!0)},fchmod(e,t){var r=s.getStreamChecked(e);s.chmod(r.node,t)},chown(e,t,r,_){var o;if(typeof e=="string"){var a=s.lookupPath(e,{follow:!_});o=a.node}else o=e;if(!o.node_ops.setattr)throw new s.ErrnoError(63);o.node_ops.setattr(o,{timestamp:Date.now()})},lchown(e,t,r){s.chown(e,t,r,!0)},fchown(e,t,r){var _=s.getStreamChecked(e);s.chown(_.node,t,r)},truncate(e,t){if(t<0)throw new s.ErrnoError(28);var r;if(typeof e=="string"){var _=s.lookupPath(e,{follow:!0});r=_.node}else r=e;if(!r.node_ops.setattr)throw new s.ErrnoError(63);if(s.isDir(r.mode))throw new s.ErrnoError(31);if(!s.isFile(r.mode))throw new s.ErrnoError(28);var o=s.nodePermissions(r,"w");if(o)throw new s.ErrnoError(o);r.node_ops.setattr(r,{size:t,timestamp:Date.now()})},ftruncate(e,t){var r=s.getStreamChecked(e);if(!(r.flags&2097155))throw new s.ErrnoError(28);s.truncate(r.node,t)},utime(e,t,r){var _=s.lookupPath(e,{follow:!0}),o=_.node;o.node_ops.setattr(o,{timestamp:Math.max(t,r)})},open(e,t,r){if(e==="")throw new s.ErrnoError(44);t=typeof t=="string"?nr(t):t,t&64?(r=typeof r>"u"?438:r,r=r&4095|32768):r=0;var _;if(typeof e=="object")_=e;else{e=Q.normalize(e);try{var o=s.lookupPath(e,{follow:!(t&131072)});_=o.node}catch{}}var a=!1;if(t&64)if(_){if(t&128)throw new s.ErrnoError(20)}else _=s.mknod(e,r,0),a=!0;if(!_)throw new s.ErrnoError(44);if(s.isChrdev(_.mode)&&(t&=-513),t&65536&&!s.isDir(_.mode))throw new s.ErrnoError(54);if(!a){var l=s.mayOpen(_,t);if(l)throw new s.ErrnoError(l)}t&512&&!a&&s.truncate(_,0),t&=-131713;var c=s.createStream({node:_,path:s.getPath(_),flags:t,seekable:!0,position:0,stream_ops:_.stream_ops,ungotten:[],error:!1});return c.stream_ops.open&&c.stream_ops.open(c),n.logReadFiles&&!(t&1)&&(s.readFiles||(s.readFiles={}),e in s.readFiles||(s.readFiles[e]=1)),c},close(e){if(s.isClosed(e))throw new s.ErrnoError(8);e.getdents&&(e.getdents=null);try{e.stream_ops.close&&e.stream_ops.close(e)}catch(t){throw t}finally{s.closeStream(e.fd)}e.fd=null},isClosed(e){return e.fd===null},llseek(e,t,r){if(s.isClosed(e))throw new s.ErrnoError(8);if(!e.seekable||!e.stream_ops.llseek)throw new s.ErrnoError(70);if(r!=0&&r!=1&&r!=2)throw new s.ErrnoError(28);return e.position=e.stream_ops.llseek(e,t,r),e.ungotten=[],e.position},read(e,t,r,_,o){if(_<0||o<0)throw new s.ErrnoError(28);if(s.isClosed(e))throw new s.ErrnoError(8);if((e.flags&2097155)===1)throw new s.ErrnoError(8);if(s.isDir(e.node.mode))throw new s.ErrnoError(31);if(!e.stream_ops.read)throw new s.ErrnoError(28);var a=typeof o<"u";if(!a)o=e.position;else if(!e.seekable)throw new s.ErrnoError(70);var l=e.stream_ops.read(e,t,r,_,o);return a||(e.position+=l),l},write(e,t,r,_,o,a){if(_<0||o<0)throw new s.ErrnoError(28);if(s.isClosed(e))throw new s.ErrnoError(8);if(!(e.flags&2097155))throw new s.ErrnoError(8);if(s.isDir(e.node.mode))throw new s.ErrnoError(31);if(!e.stream_ops.write)throw new s.ErrnoError(28);e.seekable&&e.flags&1024&&s.llseek(e,0,2);var l=typeof o<"u";if(!l)o=e.position;else if(!e.seekable)throw new s.ErrnoError(70);var c=e.stream_ops.write(e,t,r,_,o,a);return l||(e.position+=c),c},allocate(e,t,r){if(s.isClosed(e))throw new s.ErrnoError(8);if(t<0||r<=0)throw new s.ErrnoError(28);if(!(e.flags&2097155))throw new s.ErrnoError(8);if(!s.isFile(e.node.mode)&&!s.isDir(e.node.mode))throw new s.ErrnoError(43);if(!e.stream_ops.allocate)throw new s.ErrnoError(138);e.stream_ops.allocate(e,t,r)},mmap(e,t,r,_,o){if(_&2&&!(o&2)&&(e.flags&2097155)!==2)throw new s.ErrnoError(2);if((e.flags&2097155)===1)throw new s.ErrnoError(2);if(!e.stream_ops.mmap)throw new s.ErrnoError(43);return e.stream_ops.mmap(e,t,r,_,o)},msync(e,t,r,_,o){return e.stream_ops.msync?e.stream_ops.msync(e,t,r,_,o):0},ioctl(e,t,r){if(!e.stream_ops.ioctl)throw new s.ErrnoError(59);return e.stream_ops.ioctl(e,t,r)},readFile(e,t={}){if(t.flags=t.flags||0,t.encoding=t.encoding||"binary",t.encoding!=="utf8"&&t.encoding!=="binary")throw new Error(`Invalid encoding type "${t.encoding}"`);var r,_=s.open(e,t.flags),o=s.stat(e),a=o.size,l=new Uint8Array(a);return s.read(_,l,0,a,0),t.encoding==="utf8"?r=de(l,0):t.encoding==="binary"&&(r=l),s.close(_),r},writeFile(e,t,r={}){r.flags=r.flags||577;var _=s.open(e,r.flags,r.mode);if(typeof t=="string"){var o=new Uint8Array(pe(t)+1),a=De(t,o,0,o.length);s.write(_,o,0,a,void 0,r.canOwn)}else if(ArrayBuffer.isView(t))s.write(_,t,0,t.byteLength,void 0,r.canOwn);else throw new Error("Unsupported data type");s.close(_)},cwd:()=>s.currentPath,chdir(e){var t=s.lookupPath(e,{follow:!0});if(t.node===null)throw new s.ErrnoError(44);if(!s.isDir(t.node.mode))throw new s.ErrnoError(54);var r=s.nodePermissions(t.node,"x");if(r)throw new s.ErrnoError(r);s.currentPath=t.path},createDefaultDirectories(){s.mkdir("/tmp"),s.mkdir("/home"),s.mkdir("/home/web_user")},createDefaultDevices(){s.mkdir("/dev"),s.registerDevice(s.makedev(1,3),{read:()=>0,write:(_,o,a,l,c)=>l}),s.mkdev("/dev/null",s.makedev(1,3)),_e.register(s.makedev(5,0),_e.default_tty_ops),_e.register(s.makedev(6,0),_e.default_tty1_ops),s.mkdev("/dev/tty",s.makedev(5,0)),s.mkdev("/dev/tty1",s.makedev(6,0));var e=new Uint8Array(1024),t=0,r=()=>(t===0&&(t=Je(e).byteLength),e[--t]);s.createDevice("/dev","random",r),s.createDevice("/dev","urandom",r),s.mkdir("/dev/shm"),s.mkdir("/dev/shm/tmp")},createSpecialDirectories(){s.mkdir("/proc");var e=s.mkdir("/proc/self");s.mkdir("/proc/self/fd"),s.mount({mount(){var t=s.createNode(e,"fd",16895,73);return t.node_ops={lookup(r,_){var o=+_,a=s.getStreamChecked(o),l={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>a.path}};return l.parent=l,l}},t}},{},"/proc/self/fd")},createStandardStreams(){n.stdin?s.createDevice("/dev","stdin",n.stdin):s.symlink("/dev/tty","/dev/stdin"),n.stdout?s.createDevice("/dev","stdout",null,n.stdout):s.symlink("/dev/tty","/dev/stdout"),n.stderr?s.createDevice("/dev","stderr",null,n.stderr):s.symlink("/dev/tty1","/dev/stderr");var e=s.open("/dev/stdin",0),t=s.open("/dev/stdout",1),r=s.open("/dev/stderr",1)},staticInit(){[44].forEach(e=>{s.genericErrors[e]=new s.ErrnoError(e),s.genericErrors[e].stack=""}),s.nameTable=new Array(4096),s.mount(L,{},"/"),s.createDefaultDirectories(),s.createDefaultDevices(),s.createSpecialDirectories(),s.filesystems={MEMFS:L}},init(e,t,r){s.init.initialized=!0,n.stdin=e||n.stdin,n.stdout=t||n.stdout,n.stderr=r||n.stderr,s.createStandardStreams()},quit(){s.init.initialized=!1;for(var e=0;ethis.length-1||T<0)){var b=T%this.chunkSize,M=T/this.chunkSize|0;return this.getter(M)[b]}}setDataGetter(T){this.getter=T}cacheLength(){var T=new XMLHttpRequest;if(T.open("HEAD",r,!1),T.send(null),!(T.status>=200&&T.status<300||T.status===304))throw new Error("Couldn't load "+r+". Status: "+T.status);var b=Number(T.getResponseHeader("Content-length")),M,X=(M=T.getResponseHeader("Accept-Ranges"))&&M==="bytes",V=(M=T.getResponseHeader("Content-Encoding"))&&M==="gzip",Y=1024*1024;X||(Y=b);var $=(J,qe)=>{if(J>qe)throw new Error("invalid range ("+J+", "+qe+") or no bytes requested!");if(qe>b-1)throw new Error("only "+b+" bytes available! programmer error!");var H=new XMLHttpRequest;if(H.open("GET",r,!1),b!==Y&&H.setRequestHeader("Range","bytes="+J+"-"+qe),H.responseType="arraybuffer",H.overrideMimeType&&H.overrideMimeType("text/plain; charset=x-user-defined"),H.send(null),!(H.status>=200&&H.status<300||H.status===304))throw new Error("Couldn't load "+r+". Status: "+H.status);return H.response!==void 0?new Uint8Array(H.response||[]):Me(H.responseText||"",!0)},ye=this;ye.setDataGetter(J=>{var qe=J*Y,H=(J+1)*Y-1;if(H=Math.min(H,b-1),typeof ye.chunks[J]>"u"&&(ye.chunks[J]=$(qe,H)),typeof ye.chunks[J]>"u")throw new Error("doXHR failed!");return ye.chunks[J]}),(V||!b)&&(Y=b=1,b=this.getter(0).length,Y=b,q("LazyFiles on gzip forces download of the whole file when length is accessed")),this._length=b,this._chunkSize=Y,this.lengthKnown=!0}get length(){return this.lengthKnown||this.cacheLength(),this._length}get chunkSize(){return this.lengthKnown||this.cacheLength(),this._chunkSize}}if(typeof XMLHttpRequest<"u"){if(!re)throw"Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";var l=new a,c={isDevice:!1,contents:l}}else var c={isDevice:!1,url:r};var E=s.createFile(e,t,c,_,o);c.contents?E.contents=c.contents:c.url&&(E.contents=null,E.url=c.url),Object.defineProperties(E,{usedBytes:{get:function(){return this.contents.length}}});var h={},g=Object.keys(E.stream_ops);g.forEach(x=>{var T=E.stream_ops[x];h[x]=(...b)=>(s.forceLoadFile(E),T(...b))});function A(x,T,b,M,X){var V=x.node.contents;if(X>=V.length)return 0;var Y=Math.min(V.length-X,M);if(V.slice)for(var $=0;$(s.forceLoadFile(E),A(x,T,b,M,X)),h.mmap=(x,T,b,M,X)=>{s.forceLoadFile(E);var V=et(T);if(!V)throw new s.ErrnoError(48);return A(x,k,V,T,b),{ptr:V,allocated:!0}},E.stream_ops=h,E}},N={DEFAULT_POLLMASK:5,calculateAt(e,t,r){if(Q.isAbs(t))return t;var _;if(e===-100)_=s.cwd();else{var o=N.getStreamFromFD(e);_=o.path}if(t.length==0){if(!r)throw new s.ErrnoError(44);return _}return Q.join2(_,t)},doStat(e,t,r){var _=e(t);y[r>>2]=_.dev,y[r+4>>2]=_.mode,z[r+8>>2]=_.nlink,y[r+12>>2]=_.uid,y[r+16>>2]=_.gid,y[r+20>>2]=_.rdev,P=[_.size>>>0,(S=_.size,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+24>>2]=P[0],y[r+28>>2]=P[1],y[r+32>>2]=4096,y[r+36>>2]=_.blocks;var o=_.atime.getTime(),a=_.mtime.getTime(),l=_.ctime.getTime();return P=[Math.floor(o/1e3)>>>0,(S=Math.floor(o/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+40>>2]=P[0],y[r+44>>2]=P[1],z[r+48>>2]=o%1e3*1e3,P=[Math.floor(a/1e3)>>>0,(S=Math.floor(a/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+56>>2]=P[0],y[r+60>>2]=P[1],z[r+64>>2]=a%1e3*1e3,P=[Math.floor(l/1e3)>>>0,(S=Math.floor(l/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+72>>2]=P[0],y[r+76>>2]=P[1],z[r+80>>2]=l%1e3*1e3,P=[_.ino>>>0,(S=_.ino,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+88>>2]=P[0],y[r+92>>2]=P[1],0},doMsync(e,t,r,_,o){if(!s.isFile(t.node.mode))throw new s.ErrnoError(43);if(_&2)return 0;var a=C.slice(e,e+r);s.msync(t,a,o,r,_)},getStreamFromFD(e){var t=s.getStreamChecked(e);return t},varargs:void 0,getStr(e){var t=ce(e);return t}};function _r(e,t){try{return e=N.getStr(e),s.chmod(e,t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function sr(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t),r&-8)return-28;var o=s.lookupPath(t,{follow:!0}),a=o.node;if(!a)return-44;var l="";return r&4&&(l+="r"),r&2&&(l+="w"),r&1&&(l+="x"),l&&s.nodePermissions(a,l)?-2:0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function or(e,t){try{return s.fchmod(e,t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function ir(e,t,r){try{return s.fchown(e,t,r),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}function Ne(){var e=y[+N.varargs>>2];return N.varargs+=4,e}var ar=Ne;function lr(e,t,r){N.varargs=r;try{var _=N.getStreamFromFD(e);switch(t){case 0:{var o=Ne();if(o<0)return-28;for(;s.streams[o];)o++;var a;return a=s.dupStream(_,o),a.fd}case 1:case 2:return 0;case 3:return _.flags;case 4:{var o=Ne();return _.flags|=o,0}case 12:{var o=ar(),l=0;return U[o+l>>1]=2,0}case 13:case 14:return 0}return-28}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function cr(e,t){try{var r=N.getStreamFromFD(e);return N.doStat(s.stat,r.path,t)}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}var Te=(e,t)=>t+2097152>>>0<4194305-!!e?(e>>>0)+t*4294967296:NaN;function ur(e,t,r){var _=Te(t,r);try{return isNaN(_)?61:(s.ftruncate(e,_),0)}catch(o){if(typeof s>"u"||o.name!=="ErrnoError")throw o;return-o.errno}}var se=(e,t,r)=>De(e,C,t,r);function fr(e,t){try{if(t===0)return-28;var r=s.cwd(),_=pe(r)+1;return t<_?-68:(se(r,e,t),_)}catch(o){if(typeof s>"u"||o.name!=="ErrnoError")throw o;return-o.errno}}function dr(e,t){try{return e=N.getStr(e),N.doStat(s.lstat,e,t)}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function pr(e,t,r){try{return t=N.getStr(t),t=N.calculateAt(e,t),t=Q.normalize(t),t[t.length-1]==="/"&&(t=t.substr(0,t.length-1)),s.mkdir(t,r,0),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}function vr(e,t,r,_){try{t=N.getStr(t);var o=_&256,a=_&4096;return _=_&-6401,t=N.calculateAt(e,t,a),N.doStat(o?s.lstat:s.stat,t,r)}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return-l.errno}}function mr(e,t,r,_){N.varargs=_;try{t=N.getStr(t),t=N.calculateAt(e,t);var o=_?Ne():0;return s.open(t,r,o).fd}catch(a){if(typeof s>"u"||a.name!=="ErrnoError")throw a;return-a.errno}}function Er(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t),_<=0)return-28;var o=s.readlink(t),a=Math.min(_,pe(o)),l=k[r+a];return se(o,r,_+1),k[r+a]=l,a}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function qr(e){try{return e=N.getStr(e),s.rmdir(e),0}catch(t){if(typeof s>"u"||t.name!=="ErrnoError")throw t;return-t.errno}}function hr(e,t){try{return e=N.getStr(e),N.doStat(s.stat,e,t)}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function br(e,t,r){try{return t=N.getStr(t),t=N.calculateAt(e,t),r===0?s.unlink(t):r===512?s.rmdir(t):ne("Invalid flags passed to unlinkat"),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}var tt=e=>z[e>>2]+y[e+4>>2]*4294967296;function Tr(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t,!0),r){var l=tt(r),c=y[r+8>>2];o=l*1e3+c/1e6,r+=16,l=tt(r),c=y[r+8>>2],a=l*1e3+c/1e6}else var o=Date.now(),a=o;return s.utime(t,o,a),0}catch(E){if(typeof s>"u"||E.name!=="ErrnoError")throw E;return-E.errno}}var wr=e=>e%4===0&&(e%100!==0||e%400===0),yr=[0,31,60,91,121,152,182,213,244,274,305,335],Sr=[0,31,59,90,120,151,181,212,243,273,304,334],gr=e=>{var t=wr(e.getFullYear()),r=t?yr:Sr,_=r[e.getMonth()]+e.getDate()-1;return _};function Ir(e,t,r){var _=Te(e,t),o=new Date(_*1e3);y[r>>2]=o.getSeconds(),y[r+4>>2]=o.getMinutes(),y[r+8>>2]=o.getHours(),y[r+12>>2]=o.getDate(),y[r+16>>2]=o.getMonth(),y[r+20>>2]=o.getFullYear()-1900,y[r+24>>2]=o.getDay();var a=gr(o)|0;y[r+28>>2]=a,y[r+36>>2]=-(o.getTimezoneOffset()*60);var l=new Date(o.getFullYear(),0,1),c=new Date(o.getFullYear(),6,1).getTimezoneOffset(),E=l.getTimezoneOffset(),h=(c!=E&&o.getTimezoneOffset()==Math.min(E,c))|0;y[r+32>>2]=h}function Lr(e,t,r,_,o,a,l,c){var E=Te(o,a);try{if(isNaN(E))return 61;var h=N.getStreamFromFD(_),g=s.mmap(h,e,E,t,r),A=g.ptr;return y[l>>2]=g.allocated,z[c>>2]=A,0}catch(x){if(typeof s>"u"||x.name!=="ErrnoError")throw x;return-x.errno}}function xr(e,t,r,_,o,a,l){var c=Te(a,l);try{var E=N.getStreamFromFD(o);r&2&&N.doMsync(e,E,t,_,c)}catch(h){if(typeof s>"u"||h.name!=="ErrnoError")throw h;return-h.errno}}var Ar=(e,t,r,_)=>{var o=new Date().getFullYear(),a=new Date(o,0,1),l=new Date(o,6,1),c=a.getTimezoneOffset(),E=l.getTimezoneOffset(),h=Math.max(c,E);z[e>>2]=h*60,y[t>>2]=+(c!=E);var g=T=>T.toLocaleTimeString(void 0,{hour12:!1,timeZoneName:"short"}).split(" ")[1],A=g(a),x=g(l);EDate.now(),rt;rt=()=>performance.now();var Rr=()=>2147483648,kr=e=>{var t=D.buffer,r=(e-t.byteLength+65535)/65536;try{return D.grow(r),He(),1}catch{}},Or=e=>{var t=C.length;e>>>=0;var r=Rr();if(e>r)return!1;for(var _=(E,h)=>E+(h-E%h)%h,o=1;o<=4;o*=2){var a=t*(1+.2/o);a=Math.min(a,e+100663296);var l=Math.min(r,_(Math.max(e,a),65536)),c=kr(l);if(c)return!0}return!1},ze={},Qr=()=>B||"./this.program",we=()=>{if(!we.strings){var e=(typeof navigator=="object"&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",t={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:e,_:Qr()};for(var r in ze)ze[r]===void 0?delete t[r]:t[r]=ze[r];var _=[];for(var r in t)_.push(`${r}=${t[r]}`);we.strings=_}return we.strings},Cr=(e,t)=>{for(var r=0;r{var r=0;return we().forEach((_,o)=>{var a=t+r;z[e+o*4>>2]=a,Cr(_,a),r+=_.length+1}),0},Pr=(e,t)=>{var r=we();z[e>>2]=r.length;var _=0;return r.forEach(o=>_+=o.length+1),z[t>>2]=_,0};function Dr(e){try{var t=N.getStreamFromFD(e);return s.close(t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return r.errno}}function Mr(e,t){try{var r=0,_=0,o=0,a=N.getStreamFromFD(e),l=a.tty?2:s.isDir(a.mode)?3:s.isLink(a.mode)?7:4;return k[t]=l,U[t+2>>1]=o,P=[r>>>0,(S=r,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[t+8>>2]=P[0],y[t+12>>2]=P[1],P=[_>>>0,(S=_,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[t+16>>2]=P[0],y[t+20>>2]=P[1],0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return c.errno}}var Ur=(e,t,r,_)=>{for(var o=0,a=0;a>2],c=z[t+4>>2];t+=8;var E=s.read(e,k,l,c,_);if(E<0)return-1;if(o+=E,E>2]=a,0}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return l.errno}}function Br(e,t,r,_,o){var a=Te(t,r);try{if(isNaN(a))return 61;var l=N.getStreamFromFD(e);return s.llseek(l,a,_),P=[l.position>>>0,(S=l.position,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[o>>2]=P[0],y[o+4>>2]=P[1],l.getdents&&a===0&&_===0&&(l.getdents=null),0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return c.errno}}function Hr(e){try{var t=N.getStreamFromFD(e);return t.stream_ops?.fsync?t.stream_ops.fsync(t):0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return r.errno}}var Wr=(e,t,r,_)=>{for(var o=0,a=0;a>2],c=z[t+4>>2];t+=8;var E=s.write(e,k,l,c,_);if(E<0)return-1;o+=E,typeof _<"u"&&(_+=E)}return o};function jr(e,t,r,_){try{var o=N.getStreamFromFD(e),a=Wr(o,t,r);return z[_>>2]=a,0}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return l.errno}}var O=function(){let e=typeof Asyncify=="object"?Asyncify.handleAsync.bind(Asyncify):null;n.handleAsync=e;let t=new Map;n.setCallback=(r,_)=>t.set(r,_),n.getCallback=r=>t.get(r),n.deleteCallback=r=>t.delete(r),O=function(r,_,...o){let a=t.get(_),l=null,c=typeof a=="function"?a:a[l=ce(o.shift())];if(r){if(e)return e(()=>c.apply(a,o));throw new Error("Synchronous WebAssembly cannot call async function")}let E=c.apply(a,o);if(typeof E?.then=="function")throw console.error("unexpected Promise",c),new Error(`${l} unexpectedly returned a Promise`);return E}};function Gr(...e){return O(!1,...e)}function Kr(...e){return O(!0,...e)}function Xr(...e){return O(!1,...e)}function Vr(...e){return O(!0,...e)}function Yr(...e){return O(!1,...e)}function $r(...e){return O(!0,...e)}function Zr(...e){return O(!1,...e)}function Jr(...e){return O(!0,...e)}function en(...e){return O(!1,...e)}function tn(...e){return O(!0,...e)}function rn(...e){return O(!1,...e)}function nn(...e){return O(!0,...e)}function _n(...e){return O(!1,...e)}function sn(...e){return O(!0,...e)}function on(...e){return O(!1,...e)}function an(...e){return O(!0,...e)}function ln(...e){return O(!1,...e)}function cn(...e){return O(!0,...e)}function un(...e){return O(!1,...e)}function fn(...e){return O(!0,...e)}function dn(...e){return O(!1,...e)}function pn(...e){return O(!0,...e)}function vn(...e){return O(!1,...e)}function mn(...e){return O(!0,...e)}function En(...e){return O(!1,...e)}function qn(...e){return O(!0,...e)}function hn(...e){return O(!1,...e)}function bn(...e){return O(!0,...e)}function Tn(...e){return O(!1,...e)}function wn(...e){return O(!0,...e)}var yn=0,Sn=()=>Wt||yn>0,gn=e=>{j=e,Sn()||(n.onExit?.(e),W=!0),ae(e,new Ye(e))},In=(e,t)=>{j=e,gn(e)},Ln=e=>{if(e instanceof Ye||e=="unwind")return j;ae(1,e)},nt=(e,t)=>{e<128?t.push(e):t.push(e%128|128,e>>7)},xn=e=>{for(var t={i:"i32",j:"i64",f:"f32",d:"f64",e:"externref",p:"i32"},r={parameters:[],results:e[0]=="v"?[]:[t[e[0]]]},_=1;_{var r=e.slice(0,1),_=e.slice(1),o={i:127,p:127,j:126,f:125,d:124,e:111};t.push(96),nt(_.length,t);for(var a=0;a<_.length;++a)t.push(o[_[a]]);r=="v"?t.push(0):t.push(1,o[r])},Nn=(e,t)=>{if(typeof WebAssembly.Function=="function")return new WebAssembly.Function(xn(t),e);var r=[1];An(t,r);var _=[0,97,115,109,1,0,0,0,1];nt(r.length,_),_.push(...r),_.push(2,7,1,1,101,1,102,0,0,7,5,1,1,102,0,0);var o=new WebAssembly.Module(new Uint8Array(_)),a=new WebAssembly.Instance(o,{e:{f:e}}),l=a.exports.f;return l},ve,Rn=e=>ve.get(e),kn=(e,t)=>{if(me)for(var r=e;r(me||(me=new WeakMap,kn(0,ve.length)),me.get(e)||0),_t=[],Qn=()=>{if(_t.length)return _t.pop();try{ve.grow(1)}catch(e){throw e instanceof RangeError?"Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.":e}return ve.length-1},st=(e,t)=>ve.set(e,t),Cn=(e,t)=>{var r=On(e);if(r)return r;var _=Qn();try{st(_,e)}catch(a){if(!(a instanceof TypeError))throw a;var o=Nn(e,t);st(_,o)}return me.set(e,_),_},ot=e=>{var t=n["_"+e];return t},it=(e,t)=>{k.set(e,t)},at=e=>pt(e),Fn=e=>{var t=pe(e)+1,r=at(t);return se(e,r,t),r},Ee=(e,t,r,_,o)=>{var a={string:b=>{var M=0;return b!=null&&b!==0&&(M=Fn(b)),M},array:b=>{var M=at(b.length);return it(b,M),M}};function l(b){return t==="string"?ce(b):t==="boolean"?!!b:b}var c=ot(e),E=[],h=0;if(_)for(var g=0;g<_.length;g++){var A=a[r[g]];A?(h===0&&(h=Gt()),E[g]=A(_[g])):E[g]=_[g]}var x=c(...E);function T(b){return h!==0&&jt(h),l(b)}return x=T(x),x},Pn=(e,t,r,_)=>{var o=!r||r.every(l=>l==="number"||l==="boolean"),a=t!=="string";return a&&o&&!_?ot(e):(...l)=>Ee(e,t,r,l,_)},Dn=e=>ft(),Mn=(e,t,r)=>{if(r??=2147483647,r<2)return 0;r-=2;for(var _=t,o=r>1]=l,t+=2}return U[t>>1]=0,t-_},Un=(e,t,r)=>{if(r??=2147483647,r<4)return 0;for(var _=t,o=_+r-4,a=0;a=55296&&l<=57343){var c=e.charCodeAt(++a);l=65536+((l&1023)<<10)|c&1023}if(y[t>>2]=l,t+=4,t+4>o)break}return y[t>>2]=0,t-_},zn=e=>{for(var t="";;){var r=C[e++];if(!r)return t;t+=String.fromCharCode(r)}},lt=typeof TextDecoder<"u"?new TextDecoder("utf-16le"):void 0,Bn=(e,t)=>{for(var r=e,_=r>>1,o=_+t/2;!(_>=o)&&Z[_];)++_;if(r=_<<1,r-e>32&<)return lt.decode(C.subarray(e,r));for(var a="",l=0;!(l>=t/2);++l){var c=U[e+l*2>>1];if(c==0)break;a+=String.fromCharCode(c)}return a},Hn=(e,t)=>{for(var r=0,_="";!(r>=t/4);){var o=y[e+r*4>>2];if(o==0)break;if(++r,o>=65536){var a=o-65536;_+=String.fromCharCode(55296|a>>10,56320|a&1023)}else _+=String.fromCharCode(o)}return _};function Wn(e){for(var t=[],r=0;r255&&(_&=255),t.push(String.fromCharCode(_))}return t.join("")}s.createPreloadedFile=rr,s.staticInit(),O();var jn={a:Kt,Y:_r,$:sr,Z:or,X:ir,b:lr,W:cr,y:ur,Q:fr,U:dr,N:pr,T:vr,L:mr,J:Er,I:qr,V:hr,G:br,F:Tr,w:Ir,u:Lr,v:xr,M:Ar,n:Nr,m:rt,D:Or,O:Fr,P:Pr,o:Dr,E:Mr,K:zr,x:Br,S:Hr,H:jr,s:Gr,t:Kr,fa:Xr,ia:Vr,i:Yr,j:$r,c:Zr,d:Jr,ca:en,da:tn,ea:rn,ga:nn,g:_n,h:sn,z:on,A:an,e:ln,f:cn,aa:un,ba:fn,B:dn,C:pn,p:vn,q:mn,ha:En,r:qn,k:hn,l:bn,R:Tn,_:wn},i=Ht(),Gn=()=>(Gn=i.ka)(),Kn=n._sqlite3_status64=(e,t,r,_)=>(Kn=n._sqlite3_status64=i.la)(e,t,r,_),Xn=n._sqlite3_status=(e,t,r,_)=>(Xn=n._sqlite3_status=i.ma)(e,t,r,_),Vn=n._sqlite3_db_status=(e,t,r,_,o)=>(Vn=n._sqlite3_db_status=i.na)(e,t,r,_,o),Yn=n._sqlite3_msize=e=>(Yn=n._sqlite3_msize=i.oa)(e),$n=n._sqlite3_vfs_find=e=>($n=n._sqlite3_vfs_find=i.pa)(e),Zn=n._sqlite3_vfs_register=(e,t)=>(Zn=n._sqlite3_vfs_register=i.qa)(e,t),Jn=n._sqlite3_vfs_unregister=e=>(Jn=n._sqlite3_vfs_unregister=i.ra)(e),e_=n._sqlite3_release_memory=e=>(e_=n._sqlite3_release_memory=i.sa)(e),t_=n._sqlite3_soft_heap_limit64=(e,t)=>(t_=n._sqlite3_soft_heap_limit64=i.ta)(e,t),r_=n._sqlite3_memory_used=()=>(r_=n._sqlite3_memory_used=i.ua)(),n_=n._sqlite3_hard_heap_limit64=(e,t)=>(n_=n._sqlite3_hard_heap_limit64=i.va)(e,t),__=n._sqlite3_memory_highwater=e=>(__=n._sqlite3_memory_highwater=i.wa)(e),s_=n._sqlite3_malloc=e=>(s_=n._sqlite3_malloc=i.xa)(e),o_=n._sqlite3_malloc64=(e,t)=>(o_=n._sqlite3_malloc64=i.ya)(e,t),i_=n._sqlite3_free=e=>(i_=n._sqlite3_free=i.za)(e),a_=n._sqlite3_realloc=(e,t)=>(a_=n._sqlite3_realloc=i.Aa)(e,t),l_=n._sqlite3_realloc64=(e,t,r)=>(l_=n._sqlite3_realloc64=i.Ba)(e,t,r),c_=n._sqlite3_str_vappendf=(e,t,r)=>(c_=n._sqlite3_str_vappendf=i.Ca)(e,t,r),u_=n._sqlite3_str_append=(e,t,r)=>(u_=n._sqlite3_str_append=i.Da)(e,t,r),f_=n._sqlite3_str_appendchar=(e,t,r)=>(f_=n._sqlite3_str_appendchar=i.Ea)(e,t,r),d_=n._sqlite3_str_appendall=(e,t)=>(d_=n._sqlite3_str_appendall=i.Fa)(e,t),p_=n._sqlite3_str_appendf=(e,t,r)=>(p_=n._sqlite3_str_appendf=i.Ga)(e,t,r),v_=n._sqlite3_str_finish=e=>(v_=n._sqlite3_str_finish=i.Ha)(e),m_=n._sqlite3_str_errcode=e=>(m_=n._sqlite3_str_errcode=i.Ia)(e),E_=n._sqlite3_str_length=e=>(E_=n._sqlite3_str_length=i.Ja)(e),q_=n._sqlite3_str_value=e=>(q_=n._sqlite3_str_value=i.Ka)(e),h_=n._sqlite3_str_reset=e=>(h_=n._sqlite3_str_reset=i.La)(e),b_=n._sqlite3_str_new=e=>(b_=n._sqlite3_str_new=i.Ma)(e),T_=n._sqlite3_vmprintf=(e,t)=>(T_=n._sqlite3_vmprintf=i.Na)(e,t),w_=n._sqlite3_mprintf=(e,t)=>(w_=n._sqlite3_mprintf=i.Oa)(e,t),y_=n._sqlite3_vsnprintf=(e,t,r,_)=>(y_=n._sqlite3_vsnprintf=i.Pa)(e,t,r,_),S_=n._sqlite3_snprintf=(e,t,r,_)=>(S_=n._sqlite3_snprintf=i.Qa)(e,t,r,_),g_=n._sqlite3_log=(e,t,r)=>(g_=n._sqlite3_log=i.Ra)(e,t,r),I_=n._sqlite3_randomness=(e,t)=>(I_=n._sqlite3_randomness=i.Sa)(e,t),L_=n._sqlite3_stricmp=(e,t)=>(L_=n._sqlite3_stricmp=i.Ta)(e,t),x_=n._sqlite3_strnicmp=(e,t,r)=>(x_=n._sqlite3_strnicmp=i.Ua)(e,t,r),A_=n._sqlite3_os_init=()=>(A_=n._sqlite3_os_init=i.Va)(),N_=n._sqlite3_os_end=()=>(N_=n._sqlite3_os_end=i.Wa)(),R_=n._sqlite3_serialize=(e,t,r,_)=>(R_=n._sqlite3_serialize=i.Xa)(e,t,r,_),k_=n._sqlite3_prepare_v2=(e,t,r,_,o)=>(k_=n._sqlite3_prepare_v2=i.Ya)(e,t,r,_,o),O_=n._sqlite3_step=e=>(O_=n._sqlite3_step=i.Za)(e),Q_=n._sqlite3_column_int64=(e,t)=>(Q_=n._sqlite3_column_int64=i._a)(e,t),C_=n._sqlite3_reset=e=>(C_=n._sqlite3_reset=i.$a)(e),F_=n._sqlite3_exec=(e,t,r,_,o)=>(F_=n._sqlite3_exec=i.ab)(e,t,r,_,o),P_=n._sqlite3_column_int=(e,t)=>(P_=n._sqlite3_column_int=i.bb)(e,t),D_=n._sqlite3_finalize=e=>(D_=n._sqlite3_finalize=i.cb)(e),M_=n._sqlite3_deserialize=(e,t,r,_,o,a,l,c)=>(M_=n._sqlite3_deserialize=i.db)(e,t,r,_,o,a,l,c),U_=n._sqlite3_database_file_object=e=>(U_=n._sqlite3_database_file_object=i.eb)(e),z_=n._sqlite3_backup_init=(e,t,r,_)=>(z_=n._sqlite3_backup_init=i.fb)(e,t,r,_),B_=n._sqlite3_backup_step=(e,t)=>(B_=n._sqlite3_backup_step=i.gb)(e,t),H_=n._sqlite3_backup_finish=e=>(H_=n._sqlite3_backup_finish=i.hb)(e),W_=n._sqlite3_backup_remaining=e=>(W_=n._sqlite3_backup_remaining=i.ib)(e),j_=n._sqlite3_backup_pagecount=e=>(j_=n._sqlite3_backup_pagecount=i.jb)(e),G_=n._sqlite3_clear_bindings=e=>(G_=n._sqlite3_clear_bindings=i.kb)(e),K_=n._sqlite3_value_blob=e=>(K_=n._sqlite3_value_blob=i.lb)(e),X_=n._sqlite3_value_text=e=>(X_=n._sqlite3_value_text=i.mb)(e),V_=n._sqlite3_value_bytes=e=>(V_=n._sqlite3_value_bytes=i.nb)(e),Y_=n._sqlite3_value_bytes16=e=>(Y_=n._sqlite3_value_bytes16=i.ob)(e),$_=n._sqlite3_value_double=e=>($_=n._sqlite3_value_double=i.pb)(e),Z_=n._sqlite3_value_int=e=>(Z_=n._sqlite3_value_int=i.qb)(e),J_=n._sqlite3_value_int64=e=>(J_=n._sqlite3_value_int64=i.rb)(e),es=n._sqlite3_value_subtype=e=>(es=n._sqlite3_value_subtype=i.sb)(e),ts=n._sqlite3_value_pointer=(e,t)=>(ts=n._sqlite3_value_pointer=i.tb)(e,t),rs=n._sqlite3_value_text16=e=>(rs=n._sqlite3_value_text16=i.ub)(e),ns=n._sqlite3_value_text16be=e=>(ns=n._sqlite3_value_text16be=i.vb)(e),_s=n._sqlite3_value_text16le=e=>(_s=n._sqlite3_value_text16le=i.wb)(e),ss=n._sqlite3_value_type=e=>(ss=n._sqlite3_value_type=i.xb)(e),os=n._sqlite3_value_encoding=e=>(os=n._sqlite3_value_encoding=i.yb)(e),is=n._sqlite3_value_nochange=e=>(is=n._sqlite3_value_nochange=i.zb)(e),as=n._sqlite3_value_frombind=e=>(as=n._sqlite3_value_frombind=i.Ab)(e),ls=n._sqlite3_value_dup=e=>(ls=n._sqlite3_value_dup=i.Bb)(e),cs=n._sqlite3_value_free=e=>(cs=n._sqlite3_value_free=i.Cb)(e),us=n._sqlite3_result_blob=(e,t,r,_)=>(us=n._sqlite3_result_blob=i.Db)(e,t,r,_),fs=n._sqlite3_result_blob64=(e,t,r,_,o)=>(fs=n._sqlite3_result_blob64=i.Eb)(e,t,r,_,o),ds=n._sqlite3_result_double=(e,t)=>(ds=n._sqlite3_result_double=i.Fb)(e,t),ps=n._sqlite3_result_error=(e,t,r)=>(ps=n._sqlite3_result_error=i.Gb)(e,t,r),vs=n._sqlite3_result_error16=(e,t,r)=>(vs=n._sqlite3_result_error16=i.Hb)(e,t,r),ms=n._sqlite3_result_int=(e,t)=>(ms=n._sqlite3_result_int=i.Ib)(e,t),Es=n._sqlite3_result_int64=(e,t,r)=>(Es=n._sqlite3_result_int64=i.Jb)(e,t,r),qs=n._sqlite3_result_null=e=>(qs=n._sqlite3_result_null=i.Kb)(e),hs=n._sqlite3_result_pointer=(e,t,r,_)=>(hs=n._sqlite3_result_pointer=i.Lb)(e,t,r,_),bs=n._sqlite3_result_subtype=(e,t)=>(bs=n._sqlite3_result_subtype=i.Mb)(e,t),Ts=n._sqlite3_result_text=(e,t,r,_)=>(Ts=n._sqlite3_result_text=i.Nb)(e,t,r,_),ws=n._sqlite3_result_text64=(e,t,r,_,o,a)=>(ws=n._sqlite3_result_text64=i.Ob)(e,t,r,_,o,a),ys=n._sqlite3_result_text16=(e,t,r,_)=>(ys=n._sqlite3_result_text16=i.Pb)(e,t,r,_),Ss=n._sqlite3_result_text16be=(e,t,r,_)=>(Ss=n._sqlite3_result_text16be=i.Qb)(e,t,r,_),gs=n._sqlite3_result_text16le=(e,t,r,_)=>(gs=n._sqlite3_result_text16le=i.Rb)(e,t,r,_),Is=n._sqlite3_result_value=(e,t)=>(Is=n._sqlite3_result_value=i.Sb)(e,t),Ls=n._sqlite3_result_error_toobig=e=>(Ls=n._sqlite3_result_error_toobig=i.Tb)(e),xs=n._sqlite3_result_zeroblob=(e,t)=>(xs=n._sqlite3_result_zeroblob=i.Ub)(e,t),As=n._sqlite3_result_zeroblob64=(e,t,r)=>(As=n._sqlite3_result_zeroblob64=i.Vb)(e,t,r),Ns=n._sqlite3_result_error_code=(e,t)=>(Ns=n._sqlite3_result_error_code=i.Wb)(e,t),Rs=n._sqlite3_result_error_nomem=e=>(Rs=n._sqlite3_result_error_nomem=i.Xb)(e),ks=n._sqlite3_user_data=e=>(ks=n._sqlite3_user_data=i.Yb)(e),Os=n._sqlite3_context_db_handle=e=>(Os=n._sqlite3_context_db_handle=i.Zb)(e),Qs=n._sqlite3_vtab_nochange=e=>(Qs=n._sqlite3_vtab_nochange=i._b)(e),Cs=n._sqlite3_vtab_in_first=(e,t)=>(Cs=n._sqlite3_vtab_in_first=i.$b)(e,t),Fs=n._sqlite3_vtab_in_next=(e,t)=>(Fs=n._sqlite3_vtab_in_next=i.ac)(e,t),Ps=n._sqlite3_aggregate_context=(e,t)=>(Ps=n._sqlite3_aggregate_context=i.bc)(e,t),Ds=n._sqlite3_get_auxdata=(e,t)=>(Ds=n._sqlite3_get_auxdata=i.cc)(e,t),Ms=n._sqlite3_set_auxdata=(e,t,r,_)=>(Ms=n._sqlite3_set_auxdata=i.dc)(e,t,r,_),Us=n._sqlite3_column_count=e=>(Us=n._sqlite3_column_count=i.ec)(e),zs=n._sqlite3_data_count=e=>(zs=n._sqlite3_data_count=i.fc)(e),Bs=n._sqlite3_column_blob=(e,t)=>(Bs=n._sqlite3_column_blob=i.gc)(e,t),Hs=n._sqlite3_column_bytes=(e,t)=>(Hs=n._sqlite3_column_bytes=i.hc)(e,t),Ws=n._sqlite3_column_bytes16=(e,t)=>(Ws=n._sqlite3_column_bytes16=i.ic)(e,t),js=n._sqlite3_column_double=(e,t)=>(js=n._sqlite3_column_double=i.jc)(e,t),Gs=n._sqlite3_column_text=(e,t)=>(Gs=n._sqlite3_column_text=i.kc)(e,t),Ks=n._sqlite3_column_value=(e,t)=>(Ks=n._sqlite3_column_value=i.lc)(e,t),Xs=n._sqlite3_column_text16=(e,t)=>(Xs=n._sqlite3_column_text16=i.mc)(e,t),Vs=n._sqlite3_column_type=(e,t)=>(Vs=n._sqlite3_column_type=i.nc)(e,t),Ys=n._sqlite3_column_name=(e,t)=>(Ys=n._sqlite3_column_name=i.oc)(e,t),$s=n._sqlite3_column_name16=(e,t)=>($s=n._sqlite3_column_name16=i.pc)(e,t),Zs=n._sqlite3_bind_blob=(e,t,r,_,o)=>(Zs=n._sqlite3_bind_blob=i.qc)(e,t,r,_,o),Js=n._sqlite3_bind_blob64=(e,t,r,_,o,a)=>(Js=n._sqlite3_bind_blob64=i.rc)(e,t,r,_,o,a),eo=n._sqlite3_bind_double=(e,t,r)=>(eo=n._sqlite3_bind_double=i.sc)(e,t,r),to=n._sqlite3_bind_int=(e,t,r)=>(to=n._sqlite3_bind_int=i.tc)(e,t,r),ro=n._sqlite3_bind_int64=(e,t,r,_)=>(ro=n._sqlite3_bind_int64=i.uc)(e,t,r,_),no=n._sqlite3_bind_null=(e,t)=>(no=n._sqlite3_bind_null=i.vc)(e,t),_o=n._sqlite3_bind_pointer=(e,t,r,_,o)=>(_o=n._sqlite3_bind_pointer=i.wc)(e,t,r,_,o),so=n._sqlite3_bind_text=(e,t,r,_,o)=>(so=n._sqlite3_bind_text=i.xc)(e,t,r,_,o),oo=n._sqlite3_bind_text64=(e,t,r,_,o,a,l)=>(oo=n._sqlite3_bind_text64=i.yc)(e,t,r,_,o,a,l),io=n._sqlite3_bind_text16=(e,t,r,_,o)=>(io=n._sqlite3_bind_text16=i.zc)(e,t,r,_,o),ao=n._sqlite3_bind_value=(e,t,r)=>(ao=n._sqlite3_bind_value=i.Ac)(e,t,r),lo=n._sqlite3_bind_zeroblob=(e,t,r)=>(lo=n._sqlite3_bind_zeroblob=i.Bc)(e,t,r),co=n._sqlite3_bind_zeroblob64=(e,t,r,_)=>(co=n._sqlite3_bind_zeroblob64=i.Cc)(e,t,r,_),uo=n._sqlite3_bind_parameter_count=e=>(uo=n._sqlite3_bind_parameter_count=i.Dc)(e),fo=n._sqlite3_bind_parameter_name=(e,t)=>(fo=n._sqlite3_bind_parameter_name=i.Ec)(e,t),po=n._sqlite3_bind_parameter_index=(e,t)=>(po=n._sqlite3_bind_parameter_index=i.Fc)(e,t),vo=n._sqlite3_db_handle=e=>(vo=n._sqlite3_db_handle=i.Gc)(e),mo=n._sqlite3_stmt_readonly=e=>(mo=n._sqlite3_stmt_readonly=i.Hc)(e),Eo=n._sqlite3_stmt_isexplain=e=>(Eo=n._sqlite3_stmt_isexplain=i.Ic)(e),qo=n._sqlite3_stmt_explain=(e,t)=>(qo=n._sqlite3_stmt_explain=i.Jc)(e,t),ho=n._sqlite3_stmt_busy=e=>(ho=n._sqlite3_stmt_busy=i.Kc)(e),bo=n._sqlite3_next_stmt=(e,t)=>(bo=n._sqlite3_next_stmt=i.Lc)(e,t),To=n._sqlite3_stmt_status=(e,t,r)=>(To=n._sqlite3_stmt_status=i.Mc)(e,t,r),wo=n._sqlite3_sql=e=>(wo=n._sqlite3_sql=i.Nc)(e),yo=n._sqlite3_expanded_sql=e=>(yo=n._sqlite3_expanded_sql=i.Oc)(e),So=n._sqlite3_value_numeric_type=e=>(So=n._sqlite3_value_numeric_type=i.Pc)(e),go=n._sqlite3_blob_open=(e,t,r,_,o,a,l,c)=>(go=n._sqlite3_blob_open=i.Qc)(e,t,r,_,o,a,l,c),Io=n._sqlite3_blob_close=e=>(Io=n._sqlite3_blob_close=i.Rc)(e),Lo=n._sqlite3_blob_read=(e,t,r,_)=>(Lo=n._sqlite3_blob_read=i.Sc)(e,t,r,_),xo=n._sqlite3_blob_write=(e,t,r,_)=>(xo=n._sqlite3_blob_write=i.Tc)(e,t,r,_),Ao=n._sqlite3_blob_bytes=e=>(Ao=n._sqlite3_blob_bytes=i.Uc)(e),No=n._sqlite3_blob_reopen=(e,t,r)=>(No=n._sqlite3_blob_reopen=i.Vc)(e,t,r),Ro=n._sqlite3_set_authorizer=(e,t,r)=>(Ro=n._sqlite3_set_authorizer=i.Wc)(e,t,r),ko=n._sqlite3_strglob=(e,t)=>(ko=n._sqlite3_strglob=i.Xc)(e,t),Oo=n._sqlite3_strlike=(e,t,r)=>(Oo=n._sqlite3_strlike=i.Yc)(e,t,r),Qo=n._sqlite3_errmsg=e=>(Qo=n._sqlite3_errmsg=i.Zc)(e),Co=n._sqlite3_auto_extension=e=>(Co=n._sqlite3_auto_extension=i._c)(e),Fo=n._sqlite3_cancel_auto_extension=e=>(Fo=n._sqlite3_cancel_auto_extension=i.$c)(e),Po=n._sqlite3_reset_auto_extension=()=>(Po=n._sqlite3_reset_auto_extension=i.ad)(),Do=n._sqlite3_prepare=(e,t,r,_,o)=>(Do=n._sqlite3_prepare=i.bd)(e,t,r,_,o),Mo=n._sqlite3_prepare_v3=(e,t,r,_,o,a)=>(Mo=n._sqlite3_prepare_v3=i.cd)(e,t,r,_,o,a),Uo=n._sqlite3_prepare16=(e,t,r,_,o)=>(Uo=n._sqlite3_prepare16=i.dd)(e,t,r,_,o),zo=n._sqlite3_prepare16_v2=(e,t,r,_,o)=>(zo=n._sqlite3_prepare16_v2=i.ed)(e,t,r,_,o),Bo=n._sqlite3_prepare16_v3=(e,t,r,_,o,a)=>(Bo=n._sqlite3_prepare16_v3=i.fd)(e,t,r,_,o,a),Ho=n._sqlite3_get_table=(e,t,r,_,o,a)=>(Ho=n._sqlite3_get_table=i.gd)(e,t,r,_,o,a),Wo=n._sqlite3_free_table=e=>(Wo=n._sqlite3_free_table=i.hd)(e),jo=n._sqlite3_create_module=(e,t,r,_)=>(jo=n._sqlite3_create_module=i.id)(e,t,r,_),Go=n._sqlite3_create_module_v2=(e,t,r,_,o)=>(Go=n._sqlite3_create_module_v2=i.jd)(e,t,r,_,o),Ko=n._sqlite3_drop_modules=(e,t)=>(Ko=n._sqlite3_drop_modules=i.kd)(e,t),Xo=n._sqlite3_declare_vtab=(e,t)=>(Xo=n._sqlite3_declare_vtab=i.ld)(e,t),Vo=n._sqlite3_vtab_on_conflict=e=>(Vo=n._sqlite3_vtab_on_conflict=i.md)(e),Yo=n._sqlite3_vtab_config=(e,t,r)=>(Yo=n._sqlite3_vtab_config=i.nd)(e,t,r),$o=n._sqlite3_vtab_collation=(e,t)=>($o=n._sqlite3_vtab_collation=i.od)(e,t),Zo=n._sqlite3_vtab_in=(e,t,r)=>(Zo=n._sqlite3_vtab_in=i.pd)(e,t,r),Jo=n._sqlite3_vtab_rhs_value=(e,t,r)=>(Jo=n._sqlite3_vtab_rhs_value=i.qd)(e,t,r),ei=n._sqlite3_vtab_distinct=e=>(ei=n._sqlite3_vtab_distinct=i.rd)(e),ti=n._sqlite3_keyword_name=(e,t,r)=>(ti=n._sqlite3_keyword_name=i.sd)(e,t,r),ri=n._sqlite3_keyword_count=()=>(ri=n._sqlite3_keyword_count=i.td)(),ni=n._sqlite3_keyword_check=(e,t)=>(ni=n._sqlite3_keyword_check=i.ud)(e,t),_i=n._sqlite3_complete=e=>(_i=n._sqlite3_complete=i.vd)(e),si=n._sqlite3_complete16=e=>(si=n._sqlite3_complete16=i.wd)(e),oi=n._sqlite3_libversion=()=>(oi=n._sqlite3_libversion=i.xd)(),ii=n._sqlite3_libversion_number=()=>(ii=n._sqlite3_libversion_number=i.yd)(),ai=n._sqlite3_threadsafe=()=>(ai=n._sqlite3_threadsafe=i.zd)(),li=n._sqlite3_initialize=()=>(li=n._sqlite3_initialize=i.Ad)(),ci=n._sqlite3_shutdown=()=>(ci=n._sqlite3_shutdown=i.Bd)(),ui=n._sqlite3_config=(e,t)=>(ui=n._sqlite3_config=i.Cd)(e,t),fi=n._sqlite3_db_mutex=e=>(fi=n._sqlite3_db_mutex=i.Dd)(e),di=n._sqlite3_db_release_memory=e=>(di=n._sqlite3_db_release_memory=i.Ed)(e),pi=n._sqlite3_db_cacheflush=e=>(pi=n._sqlite3_db_cacheflush=i.Fd)(e),vi=n._sqlite3_db_config=(e,t,r)=>(vi=n._sqlite3_db_config=i.Gd)(e,t,r),mi=n._sqlite3_last_insert_rowid=e=>(mi=n._sqlite3_last_insert_rowid=i.Hd)(e),Ei=n._sqlite3_set_last_insert_rowid=(e,t,r)=>(Ei=n._sqlite3_set_last_insert_rowid=i.Id)(e,t,r),qi=n._sqlite3_changes64=e=>(qi=n._sqlite3_changes64=i.Jd)(e),hi=n._sqlite3_changes=e=>(hi=n._sqlite3_changes=i.Kd)(e),bi=n._sqlite3_total_changes64=e=>(bi=n._sqlite3_total_changes64=i.Ld)(e),Ti=n._sqlite3_total_changes=e=>(Ti=n._sqlite3_total_changes=i.Md)(e),wi=n._sqlite3_txn_state=(e,t)=>(wi=n._sqlite3_txn_state=i.Nd)(e,t),yi=n._sqlite3_close=e=>(yi=n._sqlite3_close=i.Od)(e),Si=n._sqlite3_close_v2=e=>(Si=n._sqlite3_close_v2=i.Pd)(e),gi=n._sqlite3_busy_handler=(e,t,r)=>(gi=n._sqlite3_busy_handler=i.Qd)(e,t,r),Ii=n._sqlite3_progress_handler=(e,t,r,_)=>(Ii=n._sqlite3_progress_handler=i.Rd)(e,t,r,_),Li=n._sqlite3_busy_timeout=(e,t)=>(Li=n._sqlite3_busy_timeout=i.Sd)(e,t),xi=n._sqlite3_interrupt=e=>(xi=n._sqlite3_interrupt=i.Td)(e),Ai=n._sqlite3_is_interrupted=e=>(Ai=n._sqlite3_is_interrupted=i.Ud)(e),Ni=n._sqlite3_create_function=(e,t,r,_,o,a,l,c)=>(Ni=n._sqlite3_create_function=i.Vd)(e,t,r,_,o,a,l,c),Ri=n._sqlite3_create_function_v2=(e,t,r,_,o,a,l,c,E)=>(Ri=n._sqlite3_create_function_v2=i.Wd)(e,t,r,_,o,a,l,c,E),ki=n._sqlite3_create_window_function=(e,t,r,_,o,a,l,c,E,h)=>(ki=n._sqlite3_create_window_function=i.Xd)(e,t,r,_,o,a,l,c,E,h),Oi=n._sqlite3_create_function16=(e,t,r,_,o,a,l,c)=>(Oi=n._sqlite3_create_function16=i.Yd)(e,t,r,_,o,a,l,c),Qi=n._sqlite3_overload_function=(e,t,r)=>(Qi=n._sqlite3_overload_function=i.Zd)(e,t,r),Ci=n._sqlite3_trace_v2=(e,t,r,_)=>(Ci=n._sqlite3_trace_v2=i._d)(e,t,r,_),Fi=n._sqlite3_commit_hook=(e,t,r)=>(Fi=n._sqlite3_commit_hook=i.$d)(e,t,r),Pi=n._sqlite3_update_hook=(e,t,r)=>(Pi=n._sqlite3_update_hook=i.ae)(e,t,r),Di=n._sqlite3_rollback_hook=(e,t,r)=>(Di=n._sqlite3_rollback_hook=i.be)(e,t,r),Mi=n._sqlite3_autovacuum_pages=(e,t,r,_)=>(Mi=n._sqlite3_autovacuum_pages=i.ce)(e,t,r,_),Ui=n._sqlite3_wal_autocheckpoint=(e,t)=>(Ui=n._sqlite3_wal_autocheckpoint=i.de)(e,t),zi=n._sqlite3_wal_hook=(e,t,r)=>(zi=n._sqlite3_wal_hook=i.ee)(e,t,r),Bi=n._sqlite3_wal_checkpoint_v2=(e,t,r,_,o)=>(Bi=n._sqlite3_wal_checkpoint_v2=i.fe)(e,t,r,_,o),Hi=n._sqlite3_wal_checkpoint=(e,t)=>(Hi=n._sqlite3_wal_checkpoint=i.ge)(e,t),Wi=n._sqlite3_error_offset=e=>(Wi=n._sqlite3_error_offset=i.he)(e),ji=n._sqlite3_errmsg16=e=>(ji=n._sqlite3_errmsg16=i.ie)(e),Gi=n._sqlite3_errcode=e=>(Gi=n._sqlite3_errcode=i.je)(e),Ki=n._sqlite3_extended_errcode=e=>(Ki=n._sqlite3_extended_errcode=i.ke)(e),Xi=n._sqlite3_system_errno=e=>(Xi=n._sqlite3_system_errno=i.le)(e),Vi=n._sqlite3_errstr=e=>(Vi=n._sqlite3_errstr=i.me)(e),Yi=n._sqlite3_limit=(e,t,r)=>(Yi=n._sqlite3_limit=i.ne)(e,t,r),$i=n._sqlite3_open=(e,t)=>($i=n._sqlite3_open=i.oe)(e,t),Zi=n._sqlite3_open_v2=(e,t,r,_)=>(Zi=n._sqlite3_open_v2=i.pe)(e,t,r,_),Ji=n._sqlite3_open16=(e,t)=>(Ji=n._sqlite3_open16=i.qe)(e,t),ea=n._sqlite3_create_collation=(e,t,r,_,o)=>(ea=n._sqlite3_create_collation=i.re)(e,t,r,_,o),ta=n._sqlite3_create_collation_v2=(e,t,r,_,o,a)=>(ta=n._sqlite3_create_collation_v2=i.se)(e,t,r,_,o,a),ra=n._sqlite3_create_collation16=(e,t,r,_,o)=>(ra=n._sqlite3_create_collation16=i.te)(e,t,r,_,o),na=n._sqlite3_collation_needed=(e,t,r)=>(na=n._sqlite3_collation_needed=i.ue)(e,t,r),_a=n._sqlite3_collation_needed16=(e,t,r)=>(_a=n._sqlite3_collation_needed16=i.ve)(e,t,r),sa=n._sqlite3_get_clientdata=(e,t)=>(sa=n._sqlite3_get_clientdata=i.we)(e,t),oa=n._sqlite3_set_clientdata=(e,t,r,_)=>(oa=n._sqlite3_set_clientdata=i.xe)(e,t,r,_),ia=n._sqlite3_get_autocommit=e=>(ia=n._sqlite3_get_autocommit=i.ye)(e),aa=n._sqlite3_table_column_metadata=(e,t,r,_,o,a,l,c,E)=>(aa=n._sqlite3_table_column_metadata=i.ze)(e,t,r,_,o,a,l,c,E),la=n._sqlite3_sleep=e=>(la=n._sqlite3_sleep=i.Ae)(e),ca=n._sqlite3_extended_result_codes=(e,t)=>(ca=n._sqlite3_extended_result_codes=i.Be)(e,t),ua=n._sqlite3_file_control=(e,t,r,_)=>(ua=n._sqlite3_file_control=i.Ce)(e,t,r,_),fa=n._sqlite3_test_control=(e,t)=>(fa=n._sqlite3_test_control=i.De)(e,t),da=n._sqlite3_create_filename=(e,t,r,_,o)=>(da=n._sqlite3_create_filename=i.Ee)(e,t,r,_,o),pa=n._sqlite3_free_filename=e=>(pa=n._sqlite3_free_filename=i.Fe)(e),va=n._sqlite3_uri_parameter=(e,t)=>(va=n._sqlite3_uri_parameter=i.Ge)(e,t),ma=n._sqlite3_uri_key=(e,t)=>(ma=n._sqlite3_uri_key=i.He)(e,t),Ea=n._sqlite3_uri_boolean=(e,t,r)=>(Ea=n._sqlite3_uri_boolean=i.Ie)(e,t,r),qa=n._sqlite3_uri_int64=(e,t,r,_)=>(qa=n._sqlite3_uri_int64=i.Je)(e,t,r,_),ha=n._sqlite3_filename_database=e=>(ha=n._sqlite3_filename_database=i.Ke)(e),ba=n._sqlite3_filename_journal=e=>(ba=n._sqlite3_filename_journal=i.Le)(e),Ta=n._sqlite3_filename_wal=e=>(Ta=n._sqlite3_filename_wal=i.Me)(e),wa=n._sqlite3_db_name=(e,t)=>(wa=n._sqlite3_db_name=i.Ne)(e,t),ya=n._sqlite3_db_filename=(e,t)=>(ya=n._sqlite3_db_filename=i.Oe)(e,t),Sa=n._sqlite3_db_readonly=(e,t)=>(Sa=n._sqlite3_db_readonly=i.Pe)(e,t),ga=n._sqlite3_compileoption_used=e=>(ga=n._sqlite3_compileoption_used=i.Qe)(e),Ia=n._sqlite3_compileoption_get=e=>(Ia=n._sqlite3_compileoption_get=i.Re)(e),La=n._sqlite3_sourceid=()=>(La=n._sqlite3_sourceid=i.Se)(),xa=n._malloc=e=>(xa=n._malloc=i.Te)(e),Aa=n._free=e=>(Aa=n._free=i.Ue)(e),Na=n._RegisterExtensionFunctions=e=>(Na=n._RegisterExtensionFunctions=i.Ve)(e),Ra=n._getSqliteFree=()=>(Ra=n._getSqliteFree=i.We)(),ct=n._main=(e,t)=>(ct=n._main=i.Xe)(e,t),ka=n._libauthorizer_set_authorizer=(e,t,r)=>(ka=n._libauthorizer_set_authorizer=i.Ye)(e,t,r),Oa=n._libfunction_create_function=(e,t,r,_,o,a,l,c)=>(Oa=n._libfunction_create_function=i.Ze)(e,t,r,_,o,a,l,c),Qa=n._libprogress_progress_handler=(e,t,r,_)=>(Qa=n._libprogress_progress_handler=i._e)(e,t,r,_),Ca=n._libvfs_vfs_register=(e,t,r,_,o,a)=>(Ca=n._libvfs_vfs_register=i.$e)(e,t,r,_,o,a),ut=(e,t)=>(ut=i.bf)(e,t),ft=()=>(ft=i.cf)(),dt=e=>(dt=i.df)(e),pt=e=>(pt=i.ef)(e),vt=()=>(vt=i.ff)(),Wa=n._sqlite3_version=5472;n.getTempRet0=Dn,n.ccall=Ee,n.cwrap=Pn,n.addFunction=Cn,n.setValue=Ae,n.getValue=$e,n.UTF8ToString=ce,n.stringToUTF8=se,n.lengthBytesUTF8=pe,n.intArrayFromString=Me,n.intArrayToString=Wn,n.AsciiToString=zn,n.UTF16ToString=Bn,n.stringToUTF16=Mn,n.UTF32ToString=Hn,n.stringToUTF32=Un,n.writeArrayToMemory=it;var Re;be=function e(){Re||mt(),Re||(be=e)};function Fa(){var e=ct,t=0,r=0;try{var _=e(t,r);return In(_,!0),_}catch(o){return Ln(o)}}function mt(){if(le>0||(Rt(),le>0))return;function e(){Re||(Re=!0,n.calledRun=!0,!W&&(kt(),Ot(),ie(n),n.onRuntimeInitialized?.(),Et&&Fa(),Qt()))}n.setStatus?(n.setStatus("Running..."),setTimeout(function(){setTimeout(function(){n.setStatus("")},1),e()},1)):e()}if(n.preInit)for(typeof n.preInit=="function"&&(n.preInit=[n.preInit]);n.preInit.length>0;)n.preInit.pop()();var Et=!0;return n.noInitialRun&&(Et=!1),mt(),function(){let e=Object.getPrototypeOf(async function(){}).constructor,t=0;n.set_authorizer=function(r,_,o){t&&(n.deleteCallback(t),n._sqlite3_free(t),t=0),t=n._sqlite3_malloc(4),Ae(t,_ instanceof e?1:0,"i32");let a=Ee("libauthorizer_set_authorizer","number",["number","number","number"],[r,_?1:0,t]);return!a&&_&&n.setCallback(t,(l,c,E,h,g,A)=>_(o,c,E,h,g,A)),a}}(),function(){let e=Object.getPrototypeOf(async function(){}).constructor,t=["xFunc","xStep","xFinal"],r=new Map;n.create_function=function(_,o,a,l,c,E,h,g){let A=n._sqlite3_malloc(4),x={xFunc:E,xStep:h,xFinal:g};Ae(A,t.reduce((b,M,X)=>x[M]instanceof e?b|1<o(a))}}(),function(){let e=["xOpen","xDelete","xAccess","xFullPathname","xRandomness","xSleep","xCurrentTime","xGetLastError","xCurrentTimeInt64","xClose","xRead","xWrite","xTruncate","xSync","xFileSize","xLock","xUnlock","xCheckReservedLock","xFileControl","xSectorSize","xDeviceCharacteristics","xShmMap","xShmLock","xShmBarrier","xShmUnmap"],t=new Map;n.vfs_register=function(r,_){let o=0,a=0;e.forEach((c,E)=>{r[c]&&(o|=1<>32n,f=BigInt(Number.MIN_SAFE_INTEGER)>>32n;return function(u,v){return v>d||v2147483647||q<-2147483648)return 25;let w=f(u,v,q);return B(d,w,G.get(u))}}(),p.bind_int64=function(){let d="sqlite3_bind_int64",f=m.cwrap(d,...I("nnnn:n"));return function(u,v,q){if(F(u),q>gt||q>32n,D=f(u,v,Number(w),Number(R));return B(d,D,G.get(u))}}(),p.bind_null=function(){let d="sqlite3_bind_null",f=m.cwrap(d,...I("nn:n"));return function(u,v){F(u);let q=f(u,v);return B(d,q,G.get(u))}}(),p.bind_parameter_name=function(){let f=m.cwrap("sqlite3_bind_parameter_name",...I("n:s"));return function(u,v){return F(u),f(u,v)}}(),p.bind_text=function(){let d="sqlite3_bind_text",f=m.cwrap(d,...I("nnnnn:n"));return function(u,v,q){F(u);let w=re(q),R=f(u,v,w,-1,K);return B(d,R,G.get(u))}}(),p.changes=function(){let f=m.cwrap("sqlite3_changes",...I("n:n"));return function(u){return fe(u),f(u)}}(),p.close=function(){let d="sqlite3_close",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){fe(u);let v=await f(u);return ne.delete(u),B(d,v,u)}}(),p.column=function(d,f){F(d);let u=p.column_type(d,f);switch(u){case 4:return p.column_blob(d,f);case 2:return p.column_double(d,f);case 1:let v=p.column_int(d,f),q=m.getTempRet0();return ge(v,q);case 5:return null;case 3:return p.column_text(d,f);default:throw new ue("unknown type",u)}},p.column_blob=function(){let f=m.cwrap("sqlite3_column_blob",...I("nn:n"));return function(u,v){F(u);let q=p.column_bytes(u,v),w=f(u,v);return m.HEAPU8.subarray(w,w+q)}}(),p.column_bytes=function(){let f=m.cwrap("sqlite3_column_bytes",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_count=function(){let f=m.cwrap("sqlite3_column_count",...I("n:n"));return function(u){return F(u),f(u)}}(),p.column_double=function(){let f=m.cwrap("sqlite3_column_double",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_int=function(){let f=m.cwrap("sqlite3_column_int64",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_int64=function(){let f=m.cwrap("sqlite3_column_int64",...I("nn:n"));return function(u,v){F(u);let q=f(u,v),w=m.getTempRet0();return he(q,w)}}(),p.column_name=function(){let f=m.cwrap("sqlite3_column_name",...I("nn:s"));return function(u,v){return F(u),f(u,v)}}(),p.column_names=function(d){let f=[],u=p.column_count(d);for(let v=0;vk(C,m.HEAP32.subarray(Z/4,Z/4+U)):(C,U,Z)=>k(C,m.HEAP32.subarray(Z/4,Z/4+U))}let j=m.create_function(d,f,u,v,q,w&&W(w),R&&W(R),D);return B("sqlite3_create_function",j,d)},p.data_count=function(){let f=m.cwrap("sqlite3_data_count",...I("n:n"));return function(u){return F(u),f(u)}}(),p.exec=async function(d,f,u){for await(let v of p.statements(d,f)){let q;for(;await p.step(v)===100;)if(u){q=q??p.column_names(v);let w=p.row(v);await u(w,q)}}return 0},p.finalize=function(){let f=m.cwrap("sqlite3_finalize",...I("n:n"),{async:Se});return async function(u){let v=await f(u);return G.delete(u),v}}(),p.get_autocommit=function(){let f=m.cwrap("sqlite3_get_autocommit",...I("n:n"));return function(u){return f(u)}}(),p.libversion=function(){let f=m.cwrap("sqlite3_libversion",...I(":s"));return function(){return f()}}(),p.libversion_number=function(){let f=m.cwrap("sqlite3_libversion_number",...I(":n"));return function(){return f()}}(),p.limit=function(){let f=m.cwrap("sqlite3_limit",...I("nnn:n"));return function(u,v,q){return f(u,v,q)}}(),p.open_v2=function(){let d="sqlite3_open_v2",f=m.cwrap(d,...I("snnn:n"),{async:Se});return async function(u,v,q){v=v||6,q=re(q);try{let w=await ae(()=>f(u,ie[0],v,q)),R=m.getValue(ie[0],"*");return ne.add(R),m.ccall("RegisterExtensionFunctions","void",["number"],[R]),B(d,w),R}finally{m._sqlite3_free(q)}}}(),p.progress_handler=function(d,f,u,v){fe(d),m.progress_handler(d,f,u,v)},p.reset=function(){let d="sqlite3_reset",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){F(u);let v=await f(u);return B(d,v,G.get(u))}}(),p.result=function(d,f){switch(typeof f){case"number":f===(f|0)?p.result_int(d,f):p.result_double(d,f);break;case"string":p.result_text(d,f);break;default:if(f instanceof Uint8Array||Array.isArray(f))p.result_blob(d,f);else if(f===null)p.result_null(d);else{if(typeof f=="bigint")return p.result_int64(d,f);console.warn("unknown result converted to null",f),p.result_null(d)}break}},p.result_blob=function(){let f=m.cwrap("sqlite3_result_blob",...I("nnnn:n"));return function(u,v){let q=v.byteLength??v.length,w=m._sqlite3_malloc(q);m.HEAPU8.subarray(w).set(v),f(u,w,q,K)}}(),p.result_double=function(){let f=m.cwrap("sqlite3_result_double",...I("nn:n"));return function(u,v){f(u,v)}}(),p.result_int=function(){let f=m.cwrap("sqlite3_result_int",...I("nn:n"));return function(u,v){f(u,v)}}(),p.result_int64=function(){let f=m.cwrap("sqlite3_result_int64",...I("nnn:n"));return function(u,v){if(v>gt||v>32n;f(u,Number(q),Number(w))}}(),p.result_null=function(){let f=m.cwrap("sqlite3_result_null",...I("n:n"));return function(u){f(u)}}(),p.result_text=function(){let f=m.cwrap("sqlite3_result_text",...I("nnnn:n"));return function(u,v){let q=re(v);f(u,q,-1,K)}}(),p.row=function(d){let f=[],u=p.data_count(d);for(let v=0;vR(v(D,W,j,k,C,U)):(D,W,j,k,C,U)=>R(v(D,W,j,k,C,U))}let w=m.set_authorizer(d,q(f),u);return B("sqlite3_set_authorizer",w,d)},p.sql=function(){let f=m.cwrap("sqlite3_sql",...I("n:s"));return function(u){return F(u),f(u)}}(),p.statements=function(d,f,u={}){let v=m.cwrap("sqlite3_prepare_v3","number",["number","number","number","number","number","number"],{async:!0});return async function*(){let q=[];try{let U=function(){C&&!u.unscoped&&p.finalize(C),C=0},w=new TextEncoder().encode(f),R=w.byteLength-w.byteLength%4+12,D=m._sqlite3_malloc(R),W=D+w.byteLength+1;q.push(()=>m._sqlite3_free(D)),m.HEAPU8.set(w,D),m.HEAPU8[W-1]=0;let j=D+R-8,k=D+R-4,C;q.push(U),m.setValue(k,D,"*");do{U();let Z=m.getValue(k,"*"),y=await ae(()=>v(d,Z,W-k,u.flags||0,j,k));y!==0&&B("sqlite3_prepare_v3",y,d),C=m.getValue(j,"*"),C&&(G.set(C,d),yield C)}while(C)}finally{for(;q.length;)q.pop()()}}()},p.step=function(){let d="sqlite3_step",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){F(u);let v=await ae(()=>f(u));return B(d,v,G.get(u),[100,101])}}(),p.value=function(d){let f=p.value_type(d);switch(f){case 4:return p.value_blob(d);case 2:return p.value_double(d);case 1:let u=p.value_int(d),v=m.getTempRet0();return ge(u,v);case 5:return null;case 3:return p.value_text(d);default:throw new ue("unknown type",f)}},p.value_blob=function(){let f=m.cwrap("sqlite3_value_blob",...I("n:n"));return function(u){let v=p.value_bytes(u),q=f(u);return m.HEAPU8.subarray(q,q+v)}}(),p.value_bytes=function(){let f=m.cwrap("sqlite3_value_bytes",...I("n:n"));return function(u){return f(u)}}(),p.value_double=function(){let f=m.cwrap("sqlite3_value_double",...I("n:n"));return function(u){return f(u)}}(),p.value_int=function(){let f=m.cwrap("sqlite3_value_int64",...I("n:n"));return function(u){return f(u)}}(),p.value_int64=function(){let f=m.cwrap("sqlite3_value_int64",...I("n:n"));return function(u){let v=f(u),q=m.getTempRet0();return he(v,q)}}(),p.value_text=function(){let f=m.cwrap("sqlite3_value_text",...I("n:s"));return function(u){return f(u)}}(),p.value_type=function(){let f=m.cwrap("sqlite3_value_type",...I("n:n"));return function(u){return f(u)}}(),p.vfs_register=function(d,f){let u=m.vfs_register(d,f);return B("sqlite3_vfs_register",u)};function B(d,f,u=null,v=[0]){if(v.includes(f))return f;let q=u?m.ccall("sqlite3_errmsg","string",["number"],[u]):d;throw new ue(q,f)}async function ae(d){let f;do m.retryOps.length&&(await Promise.all(m.retryOps),m.retryOps=[]),f=await d();while(f&&m.retryOps.length);return f}return p}function I(m){let p=[],K=m.match(/([ns@]*):([nsv@])/);switch(K[2]){case"n":p.push("number");break;case"s":p.push("string");break;case"v":p.push(null);break}let n=[];for(let ie of K[1])switch(ie){case"n":n.push("number");break;case"s":n.push("string");break}return p.push(n),p}var ja=(()=>{var m=import.meta.url;return function(p={}){var K,n=p,ie,re,he=new Promise((e,t)=>{ie=e,re=t}),ge=typeof window=="object",ne=typeof importScripts=="function",fe=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string",G=Object.assign({},n),F=[],B="./this.program",ae=(e,t)=>{throw t},d="";function f(e){return n.locateFile?n.locateFile(e,d):d+e}var u,v;(ge||ne)&&(ne?d=self.location.href:typeof document<"u"&&document.currentScript&&(d=document.currentScript.src),m&&(d=m),d.startsWith("blob:")?d="":d=d.substr(0,d.replace(/[?#].*/,"").lastIndexOf("/")+1),ne&&(v=e=>{var t=new XMLHttpRequest;return t.open("GET",e,!1),t.responseType="arraybuffer",t.send(null),new Uint8Array(t.response)}),u=e=>fetch(e,{credentials:"same-origin"}).then(t=>t.ok?t.arrayBuffer():Promise.reject(new Error(t.status+" : "+t.url))));var q=n.print||console.log.bind(console),w=n.printErr||console.error.bind(console);Object.assign(n,G),G=null,n.arguments&&(F=n.arguments),n.thisProgram&&(B=n.thisProgram),n.quit&&(ae=n.quit);var R;n.wasmBinary&&(R=n.wasmBinary);var D,W=!1,j,k,C,U,Z,y,z,Oe,Qe;function He(){var e=D.buffer;n.HEAP8=k=new Int8Array(e),n.HEAP16=U=new Int16Array(e),n.HEAPU8=C=new Uint8Array(e),n.HEAPU16=Z=new Uint16Array(e),n.HEAP32=y=new Int32Array(e),n.HEAPU32=z=new Uint32Array(e),n.HEAPF32=Oe=new Float32Array(e),n.HEAPF64=Qe=new Float64Array(e)}var We=[],je=[],Rt=[],Ge=[],kt=!1;function Ot(){if(n.preRun)for(typeof n.preRun=="function"&&(n.preRun=[n.preRun]);n.preRun.length;)Pt(n.preRun.shift());xe(We)}function Qt(){kt=!0,!n.noFSInit&&!s.init.initialized&&s.init(),s.ignorePermissions=!1,se.init(),xe(je)}function Ct(){xe(Rt)}function Ft(){if(n.postRun)for(typeof n.postRun=="function"&&(n.postRun=[n.postRun]);n.postRun.length;)Mt(n.postRun.shift());xe(Ge)}function Pt(e){We.unshift(e)}function Dt(e){je.unshift(e)}function Mt(e){Ge.unshift(e)}var le=0,Ce=null,be=null;function Ka(e){return e}function Fe(e){le++,n.monitorRunDependencies?.(le)}function Ie(e){if(le--,n.monitorRunDependencies?.(le),le==0&&(Ce!==null&&(clearInterval(Ce),Ce=null),be)){var t=be;be=null,t()}}function _e(e){n.onAbort?.(e),e="Aborted("+e+")",w(e),W=!0,j=1,e+=". Build with -sASSERTIONS for more info.";var t=new WebAssembly.RuntimeError(e);throw re(t),t}var Ut="data:application/octet-stream;base64,",Ke=e=>e.startsWith(Ut);function zt(){if(n.locateFile){var e="wa-sqlite.wasm";return Ke(e)?e:f(e)}return new URL("wa-sqlite.wasm",import.meta.url).href}var Le;function Ve(e){if(e==Le&&R)return new Uint8Array(R);if(v)return v(e);throw"both async and sync fetching of the wasm failed"}function Bt(e){return R?Promise.resolve().then(()=>Ve(e)):u(e).then(t=>new Uint8Array(t),()=>Ve(e))}function Xe(e,t,r){return Bt(e).then(_=>WebAssembly.instantiate(_,t)).then(r,_=>{w(`failed to asynchronously prepare wasm: ${_}`),_e(_)})}function Ht(e,t,r,_){return!e&&typeof WebAssembly.instantiateStreaming=="function"&&!Ke(t)&&typeof fetch=="function"?fetch(t,{credentials:"same-origin"}).then(o=>{var a=WebAssembly.instantiateStreaming(o,r);return a.then(_,function(l){return w(`wasm streaming compile failed: ${l}`),w("falling back to ArrayBuffer instantiation"),Xe(t,r,_)})}):Xe(t,r,_)}function Wt(){return{a:Kn}}function jt(){var e=Wt();function t(_,o){return i=_.exports,D=i.ja,He(),ve=i.af,Dt(i.ka),Ie("wasm-instantiate"),i}Fe("wasm-instantiate");function r(_){t(_.instance)}if(n.instantiateWasm)try{return n.instantiateWasm(e,t)}catch(_){w(`Module.instantiateWasm callback failed with error: ${_}`),re(_)}return Le||(Le=zt()),Ht(R,Le,e,r).catch(re),{}}var S,P;function Ye(e){this.name="ExitStatus",this.message=`Program terminated with exit(${e})`,this.status=e}var xe=e=>{for(;e.length>0;)e.shift()(n)};function $e(e,t="i8"){switch(t.endsWith("*")&&(t="*"),t){case"i1":return k[e];case"i8":return k[e];case"i16":return U[e>>1];case"i32":return y[e>>2];case"i64":_e("to do getValue(i64) use WASM_BIGINT");case"float":return Oe[e>>2];case"double":return Qe[e>>3];case"*":return z[e>>2];default:_e(`invalid type for getValue: ${t}`)}}var Gt=n.noExitRuntime||!0;function Ae(e,t,r="i8"){switch(r.endsWith("*")&&(r="*"),r){case"i1":k[e]=t;break;case"i8":k[e]=t;break;case"i16":U[e>>1]=t;break;case"i32":y[e>>2]=t;break;case"i64":_e("to do setValue(i64) use WASM_BIGINT");case"float":Oe[e>>2]=t;break;case"double":Qe[e>>3]=t;break;case"*":z[e>>2]=t;break;default:_e(`invalid type for setValue: ${r}`)}}var Kt=e=>dt(e),Vt=()=>vt(),Ze=typeof TextDecoder<"u"?new TextDecoder:void 0,de=(e,t,r)=>{for(var _=t+r,o=t;e[o]&&!(o>=_);)++o;if(o-t>16&&e.buffer&&Ze)return Ze.decode(e.subarray(t,o));for(var a="";t>10,56320|h&1023)}}return a},ce=(e,t)=>e?de(C,e,t):"",Xt=(e,t,r,_)=>{_e(`Assertion failed: ${ce(e)}, at: `+[t?ce(t):"unknown filename",r,_?ce(_):"unknown function"])},Q={isAbs:e=>e.charAt(0)==="/",splitPath:e=>{var t=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return t.exec(e).slice(1)},normalizeArray:(e,t)=>{for(var r=0,_=e.length-1;_>=0;_--){var o=e[_];o==="."?e.splice(_,1):o===".."?(e.splice(_,1),r++):r&&(e.splice(_,1),r--)}if(t)for(;r;r--)e.unshift("..");return e},normalize:e=>{var t=Q.isAbs(e),r=e.substr(-1)==="/";return e=Q.normalizeArray(e.split("/").filter(_=>!!_),!t).join("/"),!e&&!t&&(e="."),e&&r&&(e+="/"),(t?"/":"")+e},dirname:e=>{var t=Q.splitPath(e),r=t[0],_=t[1];return!r&&!_?".":(_&&(_=_.substr(0,_.length-1)),r+_)},basename:e=>{if(e==="/")return"/";e=Q.normalize(e),e=e.replace(/\/$/,"");var t=e.lastIndexOf("/");return t===-1?e:e.substr(t+1)},join:(...e)=>Q.normalize(e.join("/")),join2:(e,t)=>Q.normalize(e+"/"+t)},Yt=()=>{if(typeof crypto=="object"&&typeof crypto.getRandomValues=="function")return e=>crypto.getRandomValues(e);_e("initRandomDevice")},Je=e=>(Je=Yt())(e),ee={resolve:(...e)=>{for(var t="",r=!1,_=e.length-1;_>=-1&&!r;_--){var o=_>=0?e[_]:s.cwd();if(typeof o!="string")throw new TypeError("Arguments to path.resolve must be strings");if(!o)return"";t=o+"/"+t,r=Q.isAbs(o)}return t=Q.normalizeArray(t.split("/").filter(a=>!!a),!r).join("/"),(r?"/":"")+t||"."},relative:(e,t)=>{e=ee.resolve(e).substr(1),t=ee.resolve(t).substr(1);function r(h){for(var g=0;g=0&&h[A]==="";A--);return g>A?[]:h.slice(g,A-g+1)}for(var _=r(e.split("/")),o=r(t.split("/")),a=Math.min(_.length,o.length),l=a,c=0;c{for(var t=0,r=0;r=55296&&_<=57343?(t+=4,++r):t+=3}return t},De=(e,t,r,_)=>{if(!(_>0))return 0;for(var o=r,a=r+_-1,l=0;l=55296&&c<=57343){var E=e.charCodeAt(++l);c=65536+((c&1023)<<10)|E&1023}if(c<=127){if(r>=a)break;t[r++]=c}else if(c<=2047){if(r+1>=a)break;t[r++]=192|c>>6,t[r++]=128|c&63}else if(c<=65535){if(r+2>=a)break;t[r++]=224|c>>12,t[r++]=128|c>>6&63,t[r++]=128|c&63}else{if(r+3>=a)break;t[r++]=240|c>>18,t[r++]=128|c>>12&63,t[r++]=128|c>>6&63,t[r++]=128|c&63}}return t[r]=0,r-o};function Me(e,t,r){var _=r>0?r:pe(e)+1,o=new Array(_),a=De(e,o,0,o.length);return t&&(o.length=a),o}var $t=()=>{if(!Pe.length){var e=null;if(typeof window<"u"&&typeof window.prompt=="function"&&(e=window.prompt("Input: "),e!==null&&(e+=` +`)),!e)return null;Pe=Me(e,!0)}return Pe.shift()},se={ttys:[],init(){},shutdown(){},register(e,t){se.ttys[e]={input:[],output:[],ops:t},s.registerDevice(e,se.stream_ops)},stream_ops:{open(e){var t=se.ttys[e.node.rdev];if(!t)throw new s.ErrnoError(43);e.tty=t,e.seekable=!1},close(e){e.tty.ops.fsync(e.tty)},fsync(e){e.tty.ops.fsync(e.tty)},read(e,t,r,_,o){if(!e.tty||!e.tty.ops.get_char)throw new s.ErrnoError(60);for(var a=0,l=0;l<_;l++){var c;try{c=e.tty.ops.get_char(e.tty)}catch{throw new s.ErrnoError(29)}if(c===void 0&&a===0)throw new s.ErrnoError(6);if(c==null)break;a++,t[r+l]=c}return a&&(e.node.timestamp=Date.now()),a},write(e,t,r,_,o){if(!e.tty||!e.tty.ops.put_char)throw new s.ErrnoError(60);try{for(var a=0;a<_;a++)e.tty.ops.put_char(e.tty,t[r+a])}catch{throw new s.ErrnoError(29)}return _&&(e.node.timestamp=Date.now()),a}},default_tty_ops:{get_char(e){return $t()},put_char(e,t){t===null||t===10?(q(de(e.output,0)),e.output=[]):t!=0&&e.output.push(t)},fsync(e){e.output&&e.output.length>0&&(q(de(e.output,0)),e.output=[])},ioctl_tcgets(e){return{c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(e,t,r){return 0},ioctl_tiocgwinsz(e){return[24,80]}},default_tty1_ops:{put_char(e,t){t===null||t===10?(w(de(e.output,0)),e.output=[]):t!=0&&e.output.push(t)},fsync(e){e.output&&e.output.length>0&&(w(de(e.output,0)),e.output=[])}}},Zt=(e,t)=>(C.fill(0,e,e+t),e),Jt=(e,t)=>Math.ceil(e/t)*t,et=e=>{e=Jt(e,65536);var t=ut(65536,e);return t?Zt(t,e):0},L={ops_table:null,mount(e){return L.createNode(null,"/",16895,0)},createNode(e,t,r,_){if(s.isBlkdev(r)||s.isFIFO(r))throw new s.ErrnoError(63);L.ops_table||={dir:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr,lookup:L.node_ops.lookup,mknod:L.node_ops.mknod,rename:L.node_ops.rename,unlink:L.node_ops.unlink,rmdir:L.node_ops.rmdir,readdir:L.node_ops.readdir,symlink:L.node_ops.symlink},stream:{llseek:L.stream_ops.llseek}},file:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr},stream:{llseek:L.stream_ops.llseek,read:L.stream_ops.read,write:L.stream_ops.write,allocate:L.stream_ops.allocate,mmap:L.stream_ops.mmap,msync:L.stream_ops.msync}},link:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr,readlink:L.node_ops.readlink},stream:{}},chrdev:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr},stream:s.chrdev_stream_ops}};var o=s.createNode(e,t,r,_);return s.isDir(o.mode)?(o.node_ops=L.ops_table.dir.node,o.stream_ops=L.ops_table.dir.stream,o.contents={}):s.isFile(o.mode)?(o.node_ops=L.ops_table.file.node,o.stream_ops=L.ops_table.file.stream,o.usedBytes=0,o.contents=null):s.isLink(o.mode)?(o.node_ops=L.ops_table.link.node,o.stream_ops=L.ops_table.link.stream):s.isChrdev(o.mode)&&(o.node_ops=L.ops_table.chrdev.node,o.stream_ops=L.ops_table.chrdev.stream),o.timestamp=Date.now(),e&&(e.contents[t]=o,e.timestamp=o.timestamp),o},getFileDataAsTypedArray(e){return e.contents?e.contents.subarray?e.contents.subarray(0,e.usedBytes):new Uint8Array(e.contents):new Uint8Array(0)},expandFileStorage(e,t){var r=e.contents?e.contents.length:0;if(!(r>=t)){var _=1024*1024;t=Math.max(t,r*(r<_?2:1.125)>>>0),r!=0&&(t=Math.max(t,256));var o=e.contents;e.contents=new Uint8Array(t),e.usedBytes>0&&e.contents.set(o.subarray(0,e.usedBytes),0)}},resizeFileStorage(e,t){if(e.usedBytes!=t)if(t==0)e.contents=null,e.usedBytes=0;else{var r=e.contents;e.contents=new Uint8Array(t),r&&e.contents.set(r.subarray(0,Math.min(t,e.usedBytes))),e.usedBytes=t}},node_ops:{getattr(e){var t={};return t.dev=s.isChrdev(e.mode)?e.id:1,t.ino=e.id,t.mode=e.mode,t.nlink=1,t.uid=0,t.gid=0,t.rdev=e.rdev,s.isDir(e.mode)?t.size=4096:s.isFile(e.mode)?t.size=e.usedBytes:s.isLink(e.mode)?t.size=e.link.length:t.size=0,t.atime=new Date(e.timestamp),t.mtime=new Date(e.timestamp),t.ctime=new Date(e.timestamp),t.blksize=4096,t.blocks=Math.ceil(t.size/t.blksize),t},setattr(e,t){t.mode!==void 0&&(e.mode=t.mode),t.timestamp!==void 0&&(e.timestamp=t.timestamp),t.size!==void 0&&L.resizeFileStorage(e,t.size)},lookup(e,t){throw s.genericErrors[44]},mknod(e,t,r,_){return L.createNode(e,t,r,_)},rename(e,t,r){if(s.isDir(e.mode)){var _;try{_=s.lookupNode(t,r)}catch{}if(_)for(var o in _.contents)throw new s.ErrnoError(55)}delete e.parent.contents[e.name],e.parent.timestamp=Date.now(),e.name=r,t.contents[r]=e,t.timestamp=e.parent.timestamp},unlink(e,t){delete e.contents[t],e.timestamp=Date.now()},rmdir(e,t){var r=s.lookupNode(e,t);for(var _ in r.contents)throw new s.ErrnoError(55);delete e.contents[t],e.timestamp=Date.now()},readdir(e){var t=[".",".."];for(var r of Object.keys(e.contents))t.push(r);return t},symlink(e,t,r){var _=L.createNode(e,t,41471,0);return _.link=r,_},readlink(e){if(!s.isLink(e.mode))throw new s.ErrnoError(28);return e.link}},stream_ops:{read(e,t,r,_,o){var a=e.node.contents;if(o>=e.node.usedBytes)return 0;var l=Math.min(e.node.usedBytes-o,_);if(l>8&&a.subarray)t.set(a.subarray(o,o+l),r);else for(var c=0;c0||r+t{var o=_?"":`al ${e}`;u(e).then(a=>{t(new Uint8Array(a)),o&&Ie(o)},a=>{if(r)r();else throw`Loading data file "${e}" failed.`}),o&&Fe(o)},tr=(e,t,r,_,o,a)=>{s.createDataFile(e,t,r,_,o,a)},rr=n.preloadPlugins||[],nr=(e,t,r,_)=>{typeof Browser<"u"&&Browser.init();var o=!1;return rr.forEach(a=>{o||a.canHandle(t)&&(a.handle(e,t,r,_),o=!0)}),o},_r=(e,t,r,_,o,a,l,c,E,h)=>{var g=t?ee.resolve(Q.join2(e,t)):e,A=`cp ${g}`;function x(T){function b(M){h?.(),c||tr(e,t,M,_,o,E),a?.(),Ie(A)}nr(T,g,b,()=>{l?.(),Ie(A)})||b(T)}Fe(A),typeof r=="string"?er(r,x,l):x(r)},sr=e=>{var t={r:0,"r+":2,w:577,"w+":578,a:1089,"a+":1090},r=t[e];if(typeof r>"u")throw new Error(`Unknown file open mode: ${e}`);return r},Ue=(e,t)=>{var r=0;return e&&(r|=365),t&&(r|=146),r},s={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:!1,ignorePermissions:!0,ErrnoError:class{constructor(e){this.name="ErrnoError",this.errno=e}},genericErrors:{},filesystems:null,syncFSRequests:0,FSStream:class{constructor(){this.shared={}}get object(){return this.node}set object(e){this.node=e}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(e){this.shared.flags=e}get position(){return this.shared.position}set position(e){this.shared.position=e}},FSNode:class{constructor(e,t,r,_){e||(e=this),this.parent=e,this.mount=e.mount,this.mounted=null,this.id=s.nextInode++,this.name=t,this.mode=r,this.node_ops={},this.stream_ops={},this.rdev=_,this.readMode=365,this.writeMode=146}get read(){return(this.mode&this.readMode)===this.readMode}set read(e){e?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(e){e?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return s.isDir(this.mode)}get isDevice(){return s.isChrdev(this.mode)}},lookupPath(e,t={}){if(e=ee.resolve(e),!e)return{path:"",node:null};var r={follow_mount:!0,recurse_count:0};if(t=Object.assign(r,t),t.recurse_count>8)throw new s.ErrnoError(32);for(var _=e.split("/").filter(A=>!!A),o=s.root,a="/",l=0;l<_.length;l++){var c=l===_.length-1;if(c&&t.parent)break;if(o=s.lookupNode(o,_[l]),a=Q.join2(a,_[l]),s.isMountpoint(o)&&(!c||c&&t.follow_mount)&&(o=o.mounted.root),!c||t.follow)for(var E=0;s.isLink(o.mode);){var h=s.readlink(a);a=ee.resolve(Q.dirname(a),h);var g=s.lookupPath(a,{recurse_count:t.recurse_count+1});if(o=g.node,E++>40)throw new s.ErrnoError(32)}}return{path:a,node:o}},getPath(e){for(var t;;){if(s.isRoot(e)){var r=e.mount.mountpoint;return t?r[r.length-1]!=="/"?`${r}/${t}`:r+t:r}t=t?`${e.name}/${t}`:e.name,e=e.parent}},hashName(e,t){for(var r=0,_=0;_>>0)%s.nameTable.length},hashAddNode(e){var t=s.hashName(e.parent.id,e.name);e.name_next=s.nameTable[t],s.nameTable[t]=e},hashRemoveNode(e){var t=s.hashName(e.parent.id,e.name);if(s.nameTable[t]===e)s.nameTable[t]=e.name_next;else for(var r=s.nameTable[t];r;){if(r.name_next===e){r.name_next=e.name_next;break}r=r.name_next}},lookupNode(e,t){var r=s.mayLookup(e);if(r)throw new s.ErrnoError(r);for(var _=s.hashName(e.id,t),o=s.nameTable[_];o;o=o.name_next){var a=o.name;if(o.parent.id===e.id&&a===t)return o}return s.lookup(e,t)},createNode(e,t,r,_){var o=new s.FSNode(e,t,r,_);return s.hashAddNode(o),o},destroyNode(e){s.hashRemoveNode(e)},isRoot(e){return e===e.parent},isMountpoint(e){return!!e.mounted},isFile(e){return(e&61440)===32768},isDir(e){return(e&61440)===16384},isLink(e){return(e&61440)===40960},isChrdev(e){return(e&61440)===8192},isBlkdev(e){return(e&61440)===24576},isFIFO(e){return(e&61440)===4096},isSocket(e){return(e&49152)===49152},flagsToPermissionString(e){var t=["r","w","rw"][e&3];return e&512&&(t+="w"),t},nodePermissions(e,t){return s.ignorePermissions?0:t.includes("r")&&!(e.mode&292)||t.includes("w")&&!(e.mode&146)||t.includes("x")&&!(e.mode&73)?2:0},mayLookup(e){if(!s.isDir(e.mode))return 54;var t=s.nodePermissions(e,"x");return t||(e.node_ops.lookup?0:2)},mayCreate(e,t){try{var r=s.lookupNode(e,t);return 20}catch{}return s.nodePermissions(e,"wx")},mayDelete(e,t,r){var _;try{_=s.lookupNode(e,t)}catch(a){return a.errno}var o=s.nodePermissions(e,"wx");if(o)return o;if(r){if(!s.isDir(_.mode))return 54;if(s.isRoot(_)||s.getPath(_)===s.cwd())return 10}else if(s.isDir(_.mode))return 31;return 0},mayOpen(e,t){return e?s.isLink(e.mode)?32:s.isDir(e.mode)&&(s.flagsToPermissionString(t)!=="r"||t&512)?31:s.nodePermissions(e,s.flagsToPermissionString(t)):44},MAX_OPEN_FDS:4096,nextfd(){for(var e=0;e<=s.MAX_OPEN_FDS;e++)if(!s.streams[e])return e;throw new s.ErrnoError(33)},getStreamChecked(e){var t=s.getStream(e);if(!t)throw new s.ErrnoError(8);return t},getStream:e=>s.streams[e],createStream(e,t=-1){return e=Object.assign(new s.FSStream,e),t==-1&&(t=s.nextfd()),e.fd=t,s.streams[t]=e,e},closeStream(e){s.streams[e]=null},dupStream(e,t=-1){var r=s.createStream(e,t);return r.stream_ops?.dup?.(r),r},chrdev_stream_ops:{open(e){var t=s.getDevice(e.node.rdev);e.stream_ops=t.stream_ops,e.stream_ops.open?.(e)},llseek(){throw new s.ErrnoError(70)}},major:e=>e>>8,minor:e=>e&255,makedev:(e,t)=>e<<8|t,registerDevice(e,t){s.devices[e]={stream_ops:t}},getDevice:e=>s.devices[e],getMounts(e){for(var t=[],r=[e];r.length;){var _=r.pop();t.push(_),r.push(..._.mounts)}return t},syncfs(e,t){typeof e=="function"&&(t=e,e=!1),s.syncFSRequests++,s.syncFSRequests>1&&w(`warning: ${s.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);var r=s.getMounts(s.root.mount),_=0;function o(l){return s.syncFSRequests--,t(l)}function a(l){if(l)return a.errored?void 0:(a.errored=!0,o(l));++_>=r.length&&o(null)}r.forEach(l=>{if(!l.type.syncfs)return a(null);l.type.syncfs(l,e,a)})},mount(e,t,r){var _=r==="/",o=!r,a;if(_&&s.root)throw new s.ErrnoError(10);if(!_&&!o){var l=s.lookupPath(r,{follow_mount:!1});if(r=l.path,a=l.node,s.isMountpoint(a))throw new s.ErrnoError(10);if(!s.isDir(a.mode))throw new s.ErrnoError(54)}var c={type:e,opts:t,mountpoint:r,mounts:[]},E=e.mount(c);return E.mount=c,c.root=E,_?s.root=E:a&&(a.mounted=c,a.mount&&a.mount.mounts.push(c)),E},unmount(e){var t=s.lookupPath(e,{follow_mount:!1});if(!s.isMountpoint(t.node))throw new s.ErrnoError(28);var r=t.node,_=r.mounted,o=s.getMounts(_);Object.keys(s.nameTable).forEach(l=>{for(var c=s.nameTable[l];c;){var E=c.name_next;o.includes(c.mount)&&s.destroyNode(c),c=E}}),r.mounted=null;var a=r.mount.mounts.indexOf(_);r.mount.mounts.splice(a,1)},lookup(e,t){return e.node_ops.lookup(e,t)},mknod(e,t,r){var _=s.lookupPath(e,{parent:!0}),o=_.node,a=Q.basename(e);if(!a||a==="."||a==="..")throw new s.ErrnoError(28);var l=s.mayCreate(o,a);if(l)throw new s.ErrnoError(l);if(!o.node_ops.mknod)throw new s.ErrnoError(63);return o.node_ops.mknod(o,a,t,r)},create(e,t){return t=t!==void 0?t:438,t&=4095,t|=32768,s.mknod(e,t,0)},mkdir(e,t){return t=t!==void 0?t:511,t&=1023,t|=16384,s.mknod(e,t,0)},mkdirTree(e,t){for(var r=e.split("/"),_="",o=0;o"u"&&(r=t,t=438),t|=8192,s.mknod(e,t,r)},symlink(e,t){if(!ee.resolve(e))throw new s.ErrnoError(44);var r=s.lookupPath(t,{parent:!0}),_=r.node;if(!_)throw new s.ErrnoError(44);var o=Q.basename(t),a=s.mayCreate(_,o);if(a)throw new s.ErrnoError(a);if(!_.node_ops.symlink)throw new s.ErrnoError(63);return _.node_ops.symlink(_,o,e)},rename(e,t){var r=Q.dirname(e),_=Q.dirname(t),o=Q.basename(e),a=Q.basename(t),l,c,E;if(l=s.lookupPath(e,{parent:!0}),c=l.node,l=s.lookupPath(t,{parent:!0}),E=l.node,!c||!E)throw new s.ErrnoError(44);if(c.mount!==E.mount)throw new s.ErrnoError(75);var h=s.lookupNode(c,o),g=ee.relative(e,_);if(g.charAt(0)!==".")throw new s.ErrnoError(28);if(g=ee.relative(t,r),g.charAt(0)!==".")throw new s.ErrnoError(55);var A;try{A=s.lookupNode(E,a)}catch{}if(h!==A){var x=s.isDir(h.mode),T=s.mayDelete(c,o,x);if(T)throw new s.ErrnoError(T);if(T=A?s.mayDelete(E,a,x):s.mayCreate(E,a),T)throw new s.ErrnoError(T);if(!c.node_ops.rename)throw new s.ErrnoError(63);if(s.isMountpoint(h)||A&&s.isMountpoint(A))throw new s.ErrnoError(10);if(E!==c&&(T=s.nodePermissions(c,"w"),T))throw new s.ErrnoError(T);s.hashRemoveNode(h);try{c.node_ops.rename(h,E,a),h.parent=E}catch(b){throw b}finally{s.hashAddNode(h)}}},rmdir(e){var t=s.lookupPath(e,{parent:!0}),r=t.node,_=Q.basename(e),o=s.lookupNode(r,_),a=s.mayDelete(r,_,!0);if(a)throw new s.ErrnoError(a);if(!r.node_ops.rmdir)throw new s.ErrnoError(63);if(s.isMountpoint(o))throw new s.ErrnoError(10);r.node_ops.rmdir(r,_),s.destroyNode(o)},readdir(e){var t=s.lookupPath(e,{follow:!0}),r=t.node;if(!r.node_ops.readdir)throw new s.ErrnoError(54);return r.node_ops.readdir(r)},unlink(e){var t=s.lookupPath(e,{parent:!0}),r=t.node;if(!r)throw new s.ErrnoError(44);var _=Q.basename(e),o=s.lookupNode(r,_),a=s.mayDelete(r,_,!1);if(a)throw new s.ErrnoError(a);if(!r.node_ops.unlink)throw new s.ErrnoError(63);if(s.isMountpoint(o))throw new s.ErrnoError(10);r.node_ops.unlink(r,_),s.destroyNode(o)},readlink(e){var t=s.lookupPath(e),r=t.node;if(!r)throw new s.ErrnoError(44);if(!r.node_ops.readlink)throw new s.ErrnoError(28);return ee.resolve(s.getPath(r.parent),r.node_ops.readlink(r))},stat(e,t){var r=s.lookupPath(e,{follow:!t}),_=r.node;if(!_)throw new s.ErrnoError(44);if(!_.node_ops.getattr)throw new s.ErrnoError(63);return _.node_ops.getattr(_)},lstat(e){return s.stat(e,!0)},chmod(e,t,r){var _;if(typeof e=="string"){var o=s.lookupPath(e,{follow:!r});_=o.node}else _=e;if(!_.node_ops.setattr)throw new s.ErrnoError(63);_.node_ops.setattr(_,{mode:t&4095|_.mode&-4096,timestamp:Date.now()})},lchmod(e,t){s.chmod(e,t,!0)},fchmod(e,t){var r=s.getStreamChecked(e);s.chmod(r.node,t)},chown(e,t,r,_){var o;if(typeof e=="string"){var a=s.lookupPath(e,{follow:!_});o=a.node}else o=e;if(!o.node_ops.setattr)throw new s.ErrnoError(63);o.node_ops.setattr(o,{timestamp:Date.now()})},lchown(e,t,r){s.chown(e,t,r,!0)},fchown(e,t,r){var _=s.getStreamChecked(e);s.chown(_.node,t,r)},truncate(e,t){if(t<0)throw new s.ErrnoError(28);var r;if(typeof e=="string"){var _=s.lookupPath(e,{follow:!0});r=_.node}else r=e;if(!r.node_ops.setattr)throw new s.ErrnoError(63);if(s.isDir(r.mode))throw new s.ErrnoError(31);if(!s.isFile(r.mode))throw new s.ErrnoError(28);var o=s.nodePermissions(r,"w");if(o)throw new s.ErrnoError(o);r.node_ops.setattr(r,{size:t,timestamp:Date.now()})},ftruncate(e,t){var r=s.getStreamChecked(e);if(!(r.flags&2097155))throw new s.ErrnoError(28);s.truncate(r.node,t)},utime(e,t,r){var _=s.lookupPath(e,{follow:!0}),o=_.node;o.node_ops.setattr(o,{timestamp:Math.max(t,r)})},open(e,t,r){if(e==="")throw new s.ErrnoError(44);t=typeof t=="string"?sr(t):t,t&64?(r=typeof r>"u"?438:r,r=r&4095|32768):r=0;var _;if(typeof e=="object")_=e;else{e=Q.normalize(e);try{var o=s.lookupPath(e,{follow:!(t&131072)});_=o.node}catch{}}var a=!1;if(t&64)if(_){if(t&128)throw new s.ErrnoError(20)}else _=s.mknod(e,r,0),a=!0;if(!_)throw new s.ErrnoError(44);if(s.isChrdev(_.mode)&&(t&=-513),t&65536&&!s.isDir(_.mode))throw new s.ErrnoError(54);if(!a){var l=s.mayOpen(_,t);if(l)throw new s.ErrnoError(l)}t&512&&!a&&s.truncate(_,0),t&=-131713;var c=s.createStream({node:_,path:s.getPath(_),flags:t,seekable:!0,position:0,stream_ops:_.stream_ops,ungotten:[],error:!1});return c.stream_ops.open&&c.stream_ops.open(c),n.logReadFiles&&!(t&1)&&(s.readFiles||(s.readFiles={}),e in s.readFiles||(s.readFiles[e]=1)),c},close(e){if(s.isClosed(e))throw new s.ErrnoError(8);e.getdents&&(e.getdents=null);try{e.stream_ops.close&&e.stream_ops.close(e)}catch(t){throw t}finally{s.closeStream(e.fd)}e.fd=null},isClosed(e){return e.fd===null},llseek(e,t,r){if(s.isClosed(e))throw new s.ErrnoError(8);if(!e.seekable||!e.stream_ops.llseek)throw new s.ErrnoError(70);if(r!=0&&r!=1&&r!=2)throw new s.ErrnoError(28);return e.position=e.stream_ops.llseek(e,t,r),e.ungotten=[],e.position},read(e,t,r,_,o){if(_<0||o<0)throw new s.ErrnoError(28);if(s.isClosed(e))throw new s.ErrnoError(8);if((e.flags&2097155)===1)throw new s.ErrnoError(8);if(s.isDir(e.node.mode))throw new s.ErrnoError(31);if(!e.stream_ops.read)throw new s.ErrnoError(28);var a=typeof o<"u";if(!a)o=e.position;else if(!e.seekable)throw new s.ErrnoError(70);var l=e.stream_ops.read(e,t,r,_,o);return a||(e.position+=l),l},write(e,t,r,_,o,a){if(_<0||o<0)throw new s.ErrnoError(28);if(s.isClosed(e))throw new s.ErrnoError(8);if(!(e.flags&2097155))throw new s.ErrnoError(8);if(s.isDir(e.node.mode))throw new s.ErrnoError(31);if(!e.stream_ops.write)throw new s.ErrnoError(28);e.seekable&&e.flags&1024&&s.llseek(e,0,2);var l=typeof o<"u";if(!l)o=e.position;else if(!e.seekable)throw new s.ErrnoError(70);var c=e.stream_ops.write(e,t,r,_,o,a);return l||(e.position+=c),c},allocate(e,t,r){if(s.isClosed(e))throw new s.ErrnoError(8);if(t<0||r<=0)throw new s.ErrnoError(28);if(!(e.flags&2097155))throw new s.ErrnoError(8);if(!s.isFile(e.node.mode)&&!s.isDir(e.node.mode))throw new s.ErrnoError(43);if(!e.stream_ops.allocate)throw new s.ErrnoError(138);e.stream_ops.allocate(e,t,r)},mmap(e,t,r,_,o){if(_&2&&!(o&2)&&(e.flags&2097155)!==2)throw new s.ErrnoError(2);if((e.flags&2097155)===1)throw new s.ErrnoError(2);if(!e.stream_ops.mmap)throw new s.ErrnoError(43);return e.stream_ops.mmap(e,t,r,_,o)},msync(e,t,r,_,o){return e.stream_ops.msync?e.stream_ops.msync(e,t,r,_,o):0},ioctl(e,t,r){if(!e.stream_ops.ioctl)throw new s.ErrnoError(59);return e.stream_ops.ioctl(e,t,r)},readFile(e,t={}){if(t.flags=t.flags||0,t.encoding=t.encoding||"binary",t.encoding!=="utf8"&&t.encoding!=="binary")throw new Error(`Invalid encoding type "${t.encoding}"`);var r,_=s.open(e,t.flags),o=s.stat(e),a=o.size,l=new Uint8Array(a);return s.read(_,l,0,a,0),t.encoding==="utf8"?r=de(l,0):t.encoding==="binary"&&(r=l),s.close(_),r},writeFile(e,t,r={}){r.flags=r.flags||577;var _=s.open(e,r.flags,r.mode);if(typeof t=="string"){var o=new Uint8Array(pe(t)+1),a=De(t,o,0,o.length);s.write(_,o,0,a,void 0,r.canOwn)}else if(ArrayBuffer.isView(t))s.write(_,t,0,t.byteLength,void 0,r.canOwn);else throw new Error("Unsupported data type");s.close(_)},cwd:()=>s.currentPath,chdir(e){var t=s.lookupPath(e,{follow:!0});if(t.node===null)throw new s.ErrnoError(44);if(!s.isDir(t.node.mode))throw new s.ErrnoError(54);var r=s.nodePermissions(t.node,"x");if(r)throw new s.ErrnoError(r);s.currentPath=t.path},createDefaultDirectories(){s.mkdir("/tmp"),s.mkdir("/home"),s.mkdir("/home/web_user")},createDefaultDevices(){s.mkdir("/dev"),s.registerDevice(s.makedev(1,3),{read:()=>0,write:(_,o,a,l,c)=>l}),s.mkdev("/dev/null",s.makedev(1,3)),se.register(s.makedev(5,0),se.default_tty_ops),se.register(s.makedev(6,0),se.default_tty1_ops),s.mkdev("/dev/tty",s.makedev(5,0)),s.mkdev("/dev/tty1",s.makedev(6,0));var e=new Uint8Array(1024),t=0,r=()=>(t===0&&(t=Je(e).byteLength),e[--t]);s.createDevice("/dev","random",r),s.createDevice("/dev","urandom",r),s.mkdir("/dev/shm"),s.mkdir("/dev/shm/tmp")},createSpecialDirectories(){s.mkdir("/proc");var e=s.mkdir("/proc/self");s.mkdir("/proc/self/fd"),s.mount({mount(){var t=s.createNode(e,"fd",16895,73);return t.node_ops={lookup(r,_){var o=+_,a=s.getStreamChecked(o),l={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>a.path}};return l.parent=l,l}},t}},{},"/proc/self/fd")},createStandardStreams(){n.stdin?s.createDevice("/dev","stdin",n.stdin):s.symlink("/dev/tty","/dev/stdin"),n.stdout?s.createDevice("/dev","stdout",null,n.stdout):s.symlink("/dev/tty","/dev/stdout"),n.stderr?s.createDevice("/dev","stderr",null,n.stderr):s.symlink("/dev/tty1","/dev/stderr");var e=s.open("/dev/stdin",0),t=s.open("/dev/stdout",1),r=s.open("/dev/stderr",1)},staticInit(){[44].forEach(e=>{s.genericErrors[e]=new s.ErrnoError(e),s.genericErrors[e].stack=""}),s.nameTable=new Array(4096),s.mount(L,{},"/"),s.createDefaultDirectories(),s.createDefaultDevices(),s.createSpecialDirectories(),s.filesystems={MEMFS:L}},init(e,t,r){s.init.initialized=!0,n.stdin=e||n.stdin,n.stdout=t||n.stdout,n.stderr=r||n.stderr,s.createStandardStreams()},quit(){s.init.initialized=!1;for(var e=0;ethis.length-1||T<0)){var b=T%this.chunkSize,M=T/this.chunkSize|0;return this.getter(M)[b]}}setDataGetter(T){this.getter=T}cacheLength(){var T=new XMLHttpRequest;if(T.open("HEAD",r,!1),T.send(null),!(T.status>=200&&T.status<300||T.status===304))throw new Error("Couldn't load "+r+". Status: "+T.status);var b=Number(T.getResponseHeader("Content-length")),M,V=(M=T.getResponseHeader("Accept-Ranges"))&&M==="bytes",X=(M=T.getResponseHeader("Content-Encoding"))&&M==="gzip",Y=1024*1024;V||(Y=b);var $=(J,qe)=>{if(J>qe)throw new Error("invalid range ("+J+", "+qe+") or no bytes requested!");if(qe>b-1)throw new Error("only "+b+" bytes available! programmer error!");var H=new XMLHttpRequest;if(H.open("GET",r,!1),b!==Y&&H.setRequestHeader("Range","bytes="+J+"-"+qe),H.responseType="arraybuffer",H.overrideMimeType&&H.overrideMimeType("text/plain; charset=x-user-defined"),H.send(null),!(H.status>=200&&H.status<300||H.status===304))throw new Error("Couldn't load "+r+". Status: "+H.status);return H.response!==void 0?new Uint8Array(H.response||[]):Me(H.responseText||"",!0)},ye=this;ye.setDataGetter(J=>{var qe=J*Y,H=(J+1)*Y-1;if(H=Math.min(H,b-1),typeof ye.chunks[J]>"u"&&(ye.chunks[J]=$(qe,H)),typeof ye.chunks[J]>"u")throw new Error("doXHR failed!");return ye.chunks[J]}),(X||!b)&&(Y=b=1,b=this.getter(0).length,Y=b,q("LazyFiles on gzip forces download of the whole file when length is accessed")),this._length=b,this._chunkSize=Y,this.lengthKnown=!0}get length(){return this.lengthKnown||this.cacheLength(),this._length}get chunkSize(){return this.lengthKnown||this.cacheLength(),this._chunkSize}}if(typeof XMLHttpRequest<"u"){if(!ne)throw"Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";var l=new a,c={isDevice:!1,contents:l}}else var c={isDevice:!1,url:r};var E=s.createFile(e,t,c,_,o);c.contents?E.contents=c.contents:c.url&&(E.contents=null,E.url=c.url),Object.defineProperties(E,{usedBytes:{get:function(){return this.contents.length}}});var h={},g=Object.keys(E.stream_ops);g.forEach(x=>{var T=E.stream_ops[x];h[x]=(...b)=>(s.forceLoadFile(E),T(...b))});function A(x,T,b,M,V){var X=x.node.contents;if(V>=X.length)return 0;var Y=Math.min(X.length-V,M);if(X.slice)for(var $=0;$(s.forceLoadFile(E),A(x,T,b,M,V)),h.mmap=(x,T,b,M,V)=>{s.forceLoadFile(E);var X=et(T);if(!X)throw new s.ErrnoError(48);return A(x,k,X,T,b),{ptr:X,allocated:!0}},E.stream_ops=h,E}},N={DEFAULT_POLLMASK:5,calculateAt(e,t,r){if(Q.isAbs(t))return t;var _;if(e===-100)_=s.cwd();else{var o=N.getStreamFromFD(e);_=o.path}if(t.length==0){if(!r)throw new s.ErrnoError(44);return _}return Q.join2(_,t)},doStat(e,t,r){var _=e(t);y[r>>2]=_.dev,y[r+4>>2]=_.mode,z[r+8>>2]=_.nlink,y[r+12>>2]=_.uid,y[r+16>>2]=_.gid,y[r+20>>2]=_.rdev,P=[_.size>>>0,(S=_.size,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+24>>2]=P[0],y[r+28>>2]=P[1],y[r+32>>2]=4096,y[r+36>>2]=_.blocks;var o=_.atime.getTime(),a=_.mtime.getTime(),l=_.ctime.getTime();return P=[Math.floor(o/1e3)>>>0,(S=Math.floor(o/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+40>>2]=P[0],y[r+44>>2]=P[1],z[r+48>>2]=o%1e3*1e3,P=[Math.floor(a/1e3)>>>0,(S=Math.floor(a/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+56>>2]=P[0],y[r+60>>2]=P[1],z[r+64>>2]=a%1e3*1e3,P=[Math.floor(l/1e3)>>>0,(S=Math.floor(l/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+72>>2]=P[0],y[r+76>>2]=P[1],z[r+80>>2]=l%1e3*1e3,P=[_.ino>>>0,(S=_.ino,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+88>>2]=P[0],y[r+92>>2]=P[1],0},doMsync(e,t,r,_,o){if(!s.isFile(t.node.mode))throw new s.ErrnoError(43);if(_&2)return 0;var a=C.slice(e,e+r);s.msync(t,a,o,r,_)},getStreamFromFD(e){var t=s.getStreamChecked(e);return t},varargs:void 0,getStr(e){var t=ce(e);return t}};function or(e,t){try{return e=N.getStr(e),s.chmod(e,t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function ir(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t),r&-8)return-28;var o=s.lookupPath(t,{follow:!0}),a=o.node;if(!a)return-44;var l="";return r&4&&(l+="r"),r&2&&(l+="w"),r&1&&(l+="x"),l&&s.nodePermissions(a,l)?-2:0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function ar(e,t){try{return s.fchmod(e,t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function lr(e,t,r){try{return s.fchown(e,t,r),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}function Ne(){var e=y[+N.varargs>>2];return N.varargs+=4,e}var cr=Ne;function ur(e,t,r){N.varargs=r;try{var _=N.getStreamFromFD(e);switch(t){case 0:{var o=Ne();if(o<0)return-28;for(;s.streams[o];)o++;var a;return a=s.dupStream(_,o),a.fd}case 1:case 2:return 0;case 3:return _.flags;case 4:{var o=Ne();return _.flags|=o,0}case 12:{var o=cr(),l=0;return U[o+l>>1]=2,0}case 13:case 14:return 0}return-28}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function fr(e,t){try{var r=N.getStreamFromFD(e);return N.doStat(s.stat,r.path,t)}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}var Te=(e,t)=>t+2097152>>>0<4194305-!!e?(e>>>0)+t*4294967296:NaN;function dr(e,t,r){var _=Te(t,r);try{return isNaN(_)?61:(s.ftruncate(e,_),0)}catch(o){if(typeof s>"u"||o.name!=="ErrnoError")throw o;return-o.errno}}var oe=(e,t,r)=>De(e,C,t,r);function pr(e,t){try{if(t===0)return-28;var r=s.cwd(),_=pe(r)+1;return t<_?-68:(oe(r,e,t),_)}catch(o){if(typeof s>"u"||o.name!=="ErrnoError")throw o;return-o.errno}}function vr(e,t){try{return e=N.getStr(e),N.doStat(s.lstat,e,t)}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function mr(e,t,r){try{return t=N.getStr(t),t=N.calculateAt(e,t),t=Q.normalize(t),t[t.length-1]==="/"&&(t=t.substr(0,t.length-1)),s.mkdir(t,r,0),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}function Er(e,t,r,_){try{t=N.getStr(t);var o=_&256,a=_&4096;return _=_&-6401,t=N.calculateAt(e,t,a),N.doStat(o?s.lstat:s.stat,t,r)}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return-l.errno}}function qr(e,t,r,_){N.varargs=_;try{t=N.getStr(t),t=N.calculateAt(e,t);var o=_?Ne():0;return s.open(t,r,o).fd}catch(a){if(typeof s>"u"||a.name!=="ErrnoError")throw a;return-a.errno}}function hr(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t),_<=0)return-28;var o=s.readlink(t),a=Math.min(_,pe(o)),l=k[r+a];return oe(o,r,_+1),k[r+a]=l,a}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function br(e){try{return e=N.getStr(e),s.rmdir(e),0}catch(t){if(typeof s>"u"||t.name!=="ErrnoError")throw t;return-t.errno}}function Tr(e,t){try{return e=N.getStr(e),N.doStat(s.stat,e,t)}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function wr(e,t,r){try{return t=N.getStr(t),t=N.calculateAt(e,t),r===0?s.unlink(t):r===512?s.rmdir(t):_e("Invalid flags passed to unlinkat"),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}var tt=e=>z[e>>2]+y[e+4>>2]*4294967296;function yr(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t,!0),r){var l=tt(r),c=y[r+8>>2];o=l*1e3+c/1e6,r+=16,l=tt(r),c=y[r+8>>2],a=l*1e3+c/1e6}else var o=Date.now(),a=o;return s.utime(t,o,a),0}catch(E){if(typeof s>"u"||E.name!=="ErrnoError")throw E;return-E.errno}}var Sr=e=>e%4===0&&(e%100!==0||e%400===0),gr=[0,31,60,91,121,152,182,213,244,274,305,335],Ir=[0,31,59,90,120,151,181,212,243,273,304,334],Lr=e=>{var t=Sr(e.getFullYear()),r=t?gr:Ir,_=r[e.getMonth()]+e.getDate()-1;return _};function xr(e,t,r){var _=Te(e,t),o=new Date(_*1e3);y[r>>2]=o.getSeconds(),y[r+4>>2]=o.getMinutes(),y[r+8>>2]=o.getHours(),y[r+12>>2]=o.getDate(),y[r+16>>2]=o.getMonth(),y[r+20>>2]=o.getFullYear()-1900,y[r+24>>2]=o.getDay();var a=Lr(o)|0;y[r+28>>2]=a,y[r+36>>2]=-(o.getTimezoneOffset()*60);var l=new Date(o.getFullYear(),0,1),c=new Date(o.getFullYear(),6,1).getTimezoneOffset(),E=l.getTimezoneOffset(),h=(c!=E&&o.getTimezoneOffset()==Math.min(E,c))|0;y[r+32>>2]=h}function Ar(e,t,r,_,o,a,l,c){var E=Te(o,a);try{if(isNaN(E))return 61;var h=N.getStreamFromFD(_),g=s.mmap(h,e,E,t,r),A=g.ptr;return y[l>>2]=g.allocated,z[c>>2]=A,0}catch(x){if(typeof s>"u"||x.name!=="ErrnoError")throw x;return-x.errno}}function Nr(e,t,r,_,o,a,l){var c=Te(a,l);try{var E=N.getStreamFromFD(o);r&2&&N.doMsync(e,E,t,_,c)}catch(h){if(typeof s>"u"||h.name!=="ErrnoError")throw h;return-h.errno}}var Rr=(e,t,r,_)=>{var o=new Date().getFullYear(),a=new Date(o,0,1),l=new Date(o,6,1),c=a.getTimezoneOffset(),E=l.getTimezoneOffset(),h=Math.max(c,E);z[e>>2]=h*60,y[t>>2]=+(c!=E);var g=T=>T.toLocaleTimeString(void 0,{hour12:!1,timeZoneName:"short"}).split(" ")[1],A=g(a),x=g(l);EDate.now(),rt;rt=()=>performance.now();var Or=()=>2147483648,Qr=e=>{var t=D.buffer,r=(e-t.byteLength+65535)/65536;try{return D.grow(r),He(),1}catch{}},Cr=e=>{var t=C.length;e>>>=0;var r=Or();if(e>r)return!1;for(var _=(E,h)=>E+(h-E%h)%h,o=1;o<=4;o*=2){var a=t*(1+.2/o);a=Math.min(a,e+100663296);var l=Math.min(r,_(Math.max(e,a),65536)),c=Qr(l);if(c)return!0}return!1},ze={},Fr=()=>B||"./this.program",we=()=>{if(!we.strings){var e=(typeof navigator=="object"&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",t={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:e,_:Fr()};for(var r in ze)ze[r]===void 0?delete t[r]:t[r]=ze[r];var _=[];for(var r in t)_.push(`${r}=${t[r]}`);we.strings=_}return we.strings},Pr=(e,t)=>{for(var r=0;r{var r=0;return we().forEach((_,o)=>{var a=t+r;z[e+o*4>>2]=a,Pr(_,a),r+=_.length+1}),0},Mr=(e,t)=>{var r=we();z[e>>2]=r.length;var _=0;return r.forEach(o=>_+=o.length+1),z[t>>2]=_,0};function Ur(e){try{var t=N.getStreamFromFD(e);return s.close(t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return r.errno}}function zr(e,t){try{var r=0,_=0,o=0,a=N.getStreamFromFD(e),l=a.tty?2:s.isDir(a.mode)?3:s.isLink(a.mode)?7:4;return k[t]=l,U[t+2>>1]=o,P=[r>>>0,(S=r,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[t+8>>2]=P[0],y[t+12>>2]=P[1],P=[_>>>0,(S=_,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[t+16>>2]=P[0],y[t+20>>2]=P[1],0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return c.errno}}var Br=(e,t,r,_)=>{for(var o=0,a=0;a>2],c=z[t+4>>2];t+=8;var E=s.read(e,k,l,c,_);if(E<0)return-1;if(o+=E,E>2]=a,0}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return l.errno}}function Wr(e,t,r,_,o){var a=Te(t,r);try{if(isNaN(a))return 61;var l=N.getStreamFromFD(e);return s.llseek(l,a,_),P=[l.position>>>0,(S=l.position,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[o>>2]=P[0],y[o+4>>2]=P[1],l.getdents&&a===0&&_===0&&(l.getdents=null),0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return c.errno}}function jr(e){try{var t=N.getStreamFromFD(e);return t.stream_ops?.fsync?t.stream_ops.fsync(t):0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return r.errno}}var Gr=(e,t,r,_)=>{for(var o=0,a=0;a>2],c=z[t+4>>2];t+=8;var E=s.write(e,k,l,c,_);if(E<0)return-1;o+=E,typeof _<"u"&&(_+=E)}return o};function Kr(e,t,r,_){try{var o=N.getStreamFromFD(e),a=Gr(o,t,r);return z[_>>2]=a,0}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return l.errno}}var O=function(){let e=typeof Asyncify=="object"?Asyncify.handleAsync.bind(Asyncify):null;n.handleAsync=e;let t=new Map;n.setCallback=(r,_)=>t.set(r,_),n.getCallback=r=>t.get(r),n.deleteCallback=r=>t.delete(r),O=function(r,_,...o){let a=t.get(_),l=null,c=typeof a=="function"?a:a[l=ce(o.shift())];if(r){if(e)return e(()=>c.apply(a,o));throw new Error("Synchronous WebAssembly cannot call async function")}let E=c.apply(a,o);if(typeof E?.then=="function")throw console.error("unexpected Promise",c),new Error(`${l} unexpectedly returned a Promise`);return E}};function Vr(...e){return O(!1,...e)}function Xr(...e){return O(!0,...e)}function Yr(...e){return O(!1,...e)}function $r(...e){return O(!0,...e)}function Zr(...e){return O(!1,...e)}function Jr(...e){return O(!0,...e)}function en(...e){return O(!1,...e)}function tn(...e){return O(!0,...e)}function rn(...e){return O(!1,...e)}function nn(...e){return O(!0,...e)}function _n(...e){return O(!1,...e)}function sn(...e){return O(!0,...e)}function on(...e){return O(!1,...e)}function an(...e){return O(!0,...e)}function ln(...e){return O(!1,...e)}function cn(...e){return O(!0,...e)}function un(...e){return O(!1,...e)}function fn(...e){return O(!0,...e)}function dn(...e){return O(!1,...e)}function pn(...e){return O(!0,...e)}function vn(...e){return O(!1,...e)}function mn(...e){return O(!0,...e)}function En(...e){return O(!1,...e)}function qn(...e){return O(!0,...e)}function hn(...e){return O(!1,...e)}function bn(...e){return O(!0,...e)}function Tn(...e){return O(!1,...e)}function wn(...e){return O(!0,...e)}function yn(...e){return O(!1,...e)}function Sn(...e){return O(!0,...e)}var gn=0,In=()=>Gt||gn>0,Ln=e=>{j=e,In()||(n.onExit?.(e),W=!0),ae(e,new Ye(e))},xn=(e,t)=>{j=e,Ln(e)},An=e=>{if(e instanceof Ye||e=="unwind")return j;ae(1,e)},nt=(e,t)=>{e<128?t.push(e):t.push(e%128|128,e>>7)},Nn=e=>{for(var t={i:"i32",j:"i64",f:"f32",d:"f64",e:"externref",p:"i32"},r={parameters:[],results:e[0]=="v"?[]:[t[e[0]]]},_=1;_{var r=e.slice(0,1),_=e.slice(1),o={i:127,p:127,j:126,f:125,d:124,e:111};t.push(96),nt(_.length,t);for(var a=0;a<_.length;++a)t.push(o[_[a]]);r=="v"?t.push(0):t.push(1,o[r])},kn=(e,t)=>{if(typeof WebAssembly.Function=="function")return new WebAssembly.Function(Nn(t),e);var r=[1];Rn(t,r);var _=[0,97,115,109,1,0,0,0,1];nt(r.length,_),_.push(...r),_.push(2,7,1,1,101,1,102,0,0,7,5,1,1,102,0,0);var o=new WebAssembly.Module(new Uint8Array(_)),a=new WebAssembly.Instance(o,{e:{f:e}}),l=a.exports.f;return l},ve,On=e=>ve.get(e),Qn=(e,t)=>{if(me)for(var r=e;r(me||(me=new WeakMap,Qn(0,ve.length)),me.get(e)||0),_t=[],Fn=()=>{if(_t.length)return _t.pop();try{ve.grow(1)}catch(e){throw e instanceof RangeError?"Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.":e}return ve.length-1},st=(e,t)=>ve.set(e,t),Pn=(e,t)=>{var r=Cn(e);if(r)return r;var _=Fn();try{st(_,e)}catch(a){if(!(a instanceof TypeError))throw a;var o=kn(e,t);st(_,o)}return me.set(e,_),_},ot=e=>{var t=n["_"+e];return t},it=(e,t)=>{k.set(e,t)},at=e=>pt(e),Dn=e=>{var t=pe(e)+1,r=at(t);return oe(e,r,t),r},Ee=(e,t,r,_,o)=>{var a={string:b=>{var M=0;return b!=null&&b!==0&&(M=Dn(b)),M},array:b=>{var M=at(b.length);return it(b,M),M}};function l(b){return t==="string"?ce(b):t==="boolean"?!!b:b}var c=ot(e),E=[],h=0;if(_)for(var g=0;g<_.length;g++){var A=a[r[g]];A?(h===0&&(h=Vt()),E[g]=A(_[g])):E[g]=_[g]}var x=c(...E);function T(b){return h!==0&&Kt(h),l(b)}return x=T(x),x},Mn=(e,t,r,_)=>{var o=!r||r.every(l=>l==="number"||l==="boolean"),a=t!=="string";return a&&o&&!_?ot(e):(...l)=>Ee(e,t,r,l,_)},Un=e=>ft(),zn=(e,t,r)=>{if(r??=2147483647,r<2)return 0;r-=2;for(var _=t,o=r>1]=l,t+=2}return U[t>>1]=0,t-_},Bn=(e,t,r)=>{if(r??=2147483647,r<4)return 0;for(var _=t,o=_+r-4,a=0;a=55296&&l<=57343){var c=e.charCodeAt(++a);l=65536+((l&1023)<<10)|c&1023}if(y[t>>2]=l,t+=4,t+4>o)break}return y[t>>2]=0,t-_},Hn=e=>{for(var t="";;){var r=C[e++];if(!r)return t;t+=String.fromCharCode(r)}},lt=typeof TextDecoder<"u"?new TextDecoder("utf-16le"):void 0,Wn=(e,t)=>{for(var r=e,_=r>>1,o=_+t/2;!(_>=o)&&Z[_];)++_;if(r=_<<1,r-e>32&<)return lt.decode(C.subarray(e,r));for(var a="",l=0;!(l>=t/2);++l){var c=U[e+l*2>>1];if(c==0)break;a+=String.fromCharCode(c)}return a},jn=(e,t)=>{for(var r=0,_="";!(r>=t/4);){var o=y[e+r*4>>2];if(o==0)break;if(++r,o>=65536){var a=o-65536;_+=String.fromCharCode(55296|a>>10,56320|a&1023)}else _+=String.fromCharCode(o)}return _};function Gn(e){for(var t=[],r=0;r255&&(_&=255),t.push(String.fromCharCode(_))}return t.join("")}s.createPreloadedFile=_r,s.staticInit(),O();var Kn={a:Xt,Y:or,$:ir,Z:ar,X:lr,b:ur,W:fr,y:dr,Q:pr,U:vr,N:mr,T:Er,L:qr,J:hr,I:br,V:Tr,G:wr,F:yr,w:xr,u:Ar,v:Nr,M:Rr,n:kr,m:rt,D:Cr,O:Dr,P:Mr,o:Ur,E:zr,K:Hr,x:Wr,S:jr,H:Kr,s:Vr,t:Xr,fa:Yr,ia:$r,i:Zr,j:Jr,c:en,d:tn,ca:rn,da:nn,ea:_n,ga:sn,g:on,h:an,z:ln,A:cn,e:un,f:fn,aa:dn,ba:pn,B:vn,C:mn,p:En,q:qn,ha:hn,r:bn,k:Tn,l:wn,R:yn,_:Sn},i=jt(),Vn=()=>(Vn=i.ka)(),Xn=n._sqlite3_status64=(e,t,r,_)=>(Xn=n._sqlite3_status64=i.la)(e,t,r,_),Yn=n._sqlite3_status=(e,t,r,_)=>(Yn=n._sqlite3_status=i.ma)(e,t,r,_),$n=n._sqlite3_db_status=(e,t,r,_,o)=>($n=n._sqlite3_db_status=i.na)(e,t,r,_,o),Zn=n._sqlite3_msize=e=>(Zn=n._sqlite3_msize=i.oa)(e),Jn=n._sqlite3_vfs_find=e=>(Jn=n._sqlite3_vfs_find=i.pa)(e),e_=n._sqlite3_vfs_register=(e,t)=>(e_=n._sqlite3_vfs_register=i.qa)(e,t),t_=n._sqlite3_vfs_unregister=e=>(t_=n._sqlite3_vfs_unregister=i.ra)(e),r_=n._sqlite3_release_memory=e=>(r_=n._sqlite3_release_memory=i.sa)(e),n_=n._sqlite3_soft_heap_limit64=(e,t)=>(n_=n._sqlite3_soft_heap_limit64=i.ta)(e,t),__=n._sqlite3_memory_used=()=>(__=n._sqlite3_memory_used=i.ua)(),s_=n._sqlite3_hard_heap_limit64=(e,t)=>(s_=n._sqlite3_hard_heap_limit64=i.va)(e,t),o_=n._sqlite3_memory_highwater=e=>(o_=n._sqlite3_memory_highwater=i.wa)(e),i_=n._sqlite3_malloc=e=>(i_=n._sqlite3_malloc=i.xa)(e),a_=n._sqlite3_malloc64=(e,t)=>(a_=n._sqlite3_malloc64=i.ya)(e,t),l_=n._sqlite3_free=e=>(l_=n._sqlite3_free=i.za)(e),c_=n._sqlite3_realloc=(e,t)=>(c_=n._sqlite3_realloc=i.Aa)(e,t),u_=n._sqlite3_realloc64=(e,t,r)=>(u_=n._sqlite3_realloc64=i.Ba)(e,t,r),f_=n._sqlite3_str_vappendf=(e,t,r)=>(f_=n._sqlite3_str_vappendf=i.Ca)(e,t,r),d_=n._sqlite3_str_append=(e,t,r)=>(d_=n._sqlite3_str_append=i.Da)(e,t,r),p_=n._sqlite3_str_appendchar=(e,t,r)=>(p_=n._sqlite3_str_appendchar=i.Ea)(e,t,r),v_=n._sqlite3_str_appendall=(e,t)=>(v_=n._sqlite3_str_appendall=i.Fa)(e,t),m_=n._sqlite3_str_appendf=(e,t,r)=>(m_=n._sqlite3_str_appendf=i.Ga)(e,t,r),E_=n._sqlite3_str_finish=e=>(E_=n._sqlite3_str_finish=i.Ha)(e),q_=n._sqlite3_str_errcode=e=>(q_=n._sqlite3_str_errcode=i.Ia)(e),h_=n._sqlite3_str_length=e=>(h_=n._sqlite3_str_length=i.Ja)(e),b_=n._sqlite3_str_value=e=>(b_=n._sqlite3_str_value=i.Ka)(e),T_=n._sqlite3_str_reset=e=>(T_=n._sqlite3_str_reset=i.La)(e),w_=n._sqlite3_str_new=e=>(w_=n._sqlite3_str_new=i.Ma)(e),y_=n._sqlite3_vmprintf=(e,t)=>(y_=n._sqlite3_vmprintf=i.Na)(e,t),S_=n._sqlite3_mprintf=(e,t)=>(S_=n._sqlite3_mprintf=i.Oa)(e,t),g_=n._sqlite3_vsnprintf=(e,t,r,_)=>(g_=n._sqlite3_vsnprintf=i.Pa)(e,t,r,_),I_=n._sqlite3_snprintf=(e,t,r,_)=>(I_=n._sqlite3_snprintf=i.Qa)(e,t,r,_),L_=n._sqlite3_log=(e,t,r)=>(L_=n._sqlite3_log=i.Ra)(e,t,r),x_=n._sqlite3_randomness=(e,t)=>(x_=n._sqlite3_randomness=i.Sa)(e,t),A_=n._sqlite3_stricmp=(e,t)=>(A_=n._sqlite3_stricmp=i.Ta)(e,t),N_=n._sqlite3_strnicmp=(e,t,r)=>(N_=n._sqlite3_strnicmp=i.Ua)(e,t,r),R_=n._sqlite3_os_init=()=>(R_=n._sqlite3_os_init=i.Va)(),k_=n._sqlite3_os_end=()=>(k_=n._sqlite3_os_end=i.Wa)(),O_=n._sqlite3_serialize=(e,t,r,_)=>(O_=n._sqlite3_serialize=i.Xa)(e,t,r,_),Q_=n._sqlite3_prepare_v2=(e,t,r,_,o)=>(Q_=n._sqlite3_prepare_v2=i.Ya)(e,t,r,_,o),C_=n._sqlite3_step=e=>(C_=n._sqlite3_step=i.Za)(e),F_=n._sqlite3_column_int64=(e,t)=>(F_=n._sqlite3_column_int64=i._a)(e,t),P_=n._sqlite3_reset=e=>(P_=n._sqlite3_reset=i.$a)(e),D_=n._sqlite3_exec=(e,t,r,_,o)=>(D_=n._sqlite3_exec=i.ab)(e,t,r,_,o),M_=n._sqlite3_column_int=(e,t)=>(M_=n._sqlite3_column_int=i.bb)(e,t),U_=n._sqlite3_finalize=e=>(U_=n._sqlite3_finalize=i.cb)(e),z_=n._sqlite3_deserialize=(e,t,r,_,o,a,l,c)=>(z_=n._sqlite3_deserialize=i.db)(e,t,r,_,o,a,l,c),B_=n._sqlite3_database_file_object=e=>(B_=n._sqlite3_database_file_object=i.eb)(e),H_=n._sqlite3_backup_init=(e,t,r,_)=>(H_=n._sqlite3_backup_init=i.fb)(e,t,r,_),W_=n._sqlite3_backup_step=(e,t)=>(W_=n._sqlite3_backup_step=i.gb)(e,t),j_=n._sqlite3_backup_finish=e=>(j_=n._sqlite3_backup_finish=i.hb)(e),G_=n._sqlite3_backup_remaining=e=>(G_=n._sqlite3_backup_remaining=i.ib)(e),K_=n._sqlite3_backup_pagecount=e=>(K_=n._sqlite3_backup_pagecount=i.jb)(e),V_=n._sqlite3_clear_bindings=e=>(V_=n._sqlite3_clear_bindings=i.kb)(e),X_=n._sqlite3_value_blob=e=>(X_=n._sqlite3_value_blob=i.lb)(e),Y_=n._sqlite3_value_text=e=>(Y_=n._sqlite3_value_text=i.mb)(e),$_=n._sqlite3_value_bytes=e=>($_=n._sqlite3_value_bytes=i.nb)(e),Z_=n._sqlite3_value_bytes16=e=>(Z_=n._sqlite3_value_bytes16=i.ob)(e),J_=n._sqlite3_value_double=e=>(J_=n._sqlite3_value_double=i.pb)(e),es=n._sqlite3_value_int=e=>(es=n._sqlite3_value_int=i.qb)(e),ts=n._sqlite3_value_int64=e=>(ts=n._sqlite3_value_int64=i.rb)(e),rs=n._sqlite3_value_subtype=e=>(rs=n._sqlite3_value_subtype=i.sb)(e),ns=n._sqlite3_value_pointer=(e,t)=>(ns=n._sqlite3_value_pointer=i.tb)(e,t),_s=n._sqlite3_value_text16=e=>(_s=n._sqlite3_value_text16=i.ub)(e),ss=n._sqlite3_value_text16be=e=>(ss=n._sqlite3_value_text16be=i.vb)(e),os=n._sqlite3_value_text16le=e=>(os=n._sqlite3_value_text16le=i.wb)(e),is=n._sqlite3_value_type=e=>(is=n._sqlite3_value_type=i.xb)(e),as=n._sqlite3_value_encoding=e=>(as=n._sqlite3_value_encoding=i.yb)(e),ls=n._sqlite3_value_nochange=e=>(ls=n._sqlite3_value_nochange=i.zb)(e),cs=n._sqlite3_value_frombind=e=>(cs=n._sqlite3_value_frombind=i.Ab)(e),us=n._sqlite3_value_dup=e=>(us=n._sqlite3_value_dup=i.Bb)(e),fs=n._sqlite3_value_free=e=>(fs=n._sqlite3_value_free=i.Cb)(e),ds=n._sqlite3_result_blob=(e,t,r,_)=>(ds=n._sqlite3_result_blob=i.Db)(e,t,r,_),ps=n._sqlite3_result_blob64=(e,t,r,_,o)=>(ps=n._sqlite3_result_blob64=i.Eb)(e,t,r,_,o),vs=n._sqlite3_result_double=(e,t)=>(vs=n._sqlite3_result_double=i.Fb)(e,t),ms=n._sqlite3_result_error=(e,t,r)=>(ms=n._sqlite3_result_error=i.Gb)(e,t,r),Es=n._sqlite3_result_error16=(e,t,r)=>(Es=n._sqlite3_result_error16=i.Hb)(e,t,r),qs=n._sqlite3_result_int=(e,t)=>(qs=n._sqlite3_result_int=i.Ib)(e,t),hs=n._sqlite3_result_int64=(e,t,r)=>(hs=n._sqlite3_result_int64=i.Jb)(e,t,r),bs=n._sqlite3_result_null=e=>(bs=n._sqlite3_result_null=i.Kb)(e),Ts=n._sqlite3_result_pointer=(e,t,r,_)=>(Ts=n._sqlite3_result_pointer=i.Lb)(e,t,r,_),ws=n._sqlite3_result_subtype=(e,t)=>(ws=n._sqlite3_result_subtype=i.Mb)(e,t),ys=n._sqlite3_result_text=(e,t,r,_)=>(ys=n._sqlite3_result_text=i.Nb)(e,t,r,_),Ss=n._sqlite3_result_text64=(e,t,r,_,o,a)=>(Ss=n._sqlite3_result_text64=i.Ob)(e,t,r,_,o,a),gs=n._sqlite3_result_text16=(e,t,r,_)=>(gs=n._sqlite3_result_text16=i.Pb)(e,t,r,_),Is=n._sqlite3_result_text16be=(e,t,r,_)=>(Is=n._sqlite3_result_text16be=i.Qb)(e,t,r,_),Ls=n._sqlite3_result_text16le=(e,t,r,_)=>(Ls=n._sqlite3_result_text16le=i.Rb)(e,t,r,_),xs=n._sqlite3_result_value=(e,t)=>(xs=n._sqlite3_result_value=i.Sb)(e,t),As=n._sqlite3_result_error_toobig=e=>(As=n._sqlite3_result_error_toobig=i.Tb)(e),Ns=n._sqlite3_result_zeroblob=(e,t)=>(Ns=n._sqlite3_result_zeroblob=i.Ub)(e,t),Rs=n._sqlite3_result_zeroblob64=(e,t,r)=>(Rs=n._sqlite3_result_zeroblob64=i.Vb)(e,t,r),ks=n._sqlite3_result_error_code=(e,t)=>(ks=n._sqlite3_result_error_code=i.Wb)(e,t),Os=n._sqlite3_result_error_nomem=e=>(Os=n._sqlite3_result_error_nomem=i.Xb)(e),Qs=n._sqlite3_user_data=e=>(Qs=n._sqlite3_user_data=i.Yb)(e),Cs=n._sqlite3_context_db_handle=e=>(Cs=n._sqlite3_context_db_handle=i.Zb)(e),Fs=n._sqlite3_vtab_nochange=e=>(Fs=n._sqlite3_vtab_nochange=i._b)(e),Ps=n._sqlite3_vtab_in_first=(e,t)=>(Ps=n._sqlite3_vtab_in_first=i.$b)(e,t),Ds=n._sqlite3_vtab_in_next=(e,t)=>(Ds=n._sqlite3_vtab_in_next=i.ac)(e,t),Ms=n._sqlite3_aggregate_context=(e,t)=>(Ms=n._sqlite3_aggregate_context=i.bc)(e,t),Us=n._sqlite3_get_auxdata=(e,t)=>(Us=n._sqlite3_get_auxdata=i.cc)(e,t),zs=n._sqlite3_set_auxdata=(e,t,r,_)=>(zs=n._sqlite3_set_auxdata=i.dc)(e,t,r,_),Bs=n._sqlite3_column_count=e=>(Bs=n._sqlite3_column_count=i.ec)(e),Hs=n._sqlite3_data_count=e=>(Hs=n._sqlite3_data_count=i.fc)(e),Ws=n._sqlite3_column_blob=(e,t)=>(Ws=n._sqlite3_column_blob=i.gc)(e,t),js=n._sqlite3_column_bytes=(e,t)=>(js=n._sqlite3_column_bytes=i.hc)(e,t),Gs=n._sqlite3_column_bytes16=(e,t)=>(Gs=n._sqlite3_column_bytes16=i.ic)(e,t),Ks=n._sqlite3_column_double=(e,t)=>(Ks=n._sqlite3_column_double=i.jc)(e,t),Vs=n._sqlite3_column_text=(e,t)=>(Vs=n._sqlite3_column_text=i.kc)(e,t),Xs=n._sqlite3_column_value=(e,t)=>(Xs=n._sqlite3_column_value=i.lc)(e,t),Ys=n._sqlite3_column_text16=(e,t)=>(Ys=n._sqlite3_column_text16=i.mc)(e,t),$s=n._sqlite3_column_type=(e,t)=>($s=n._sqlite3_column_type=i.nc)(e,t),Zs=n._sqlite3_column_name=(e,t)=>(Zs=n._sqlite3_column_name=i.oc)(e,t),Js=n._sqlite3_column_name16=(e,t)=>(Js=n._sqlite3_column_name16=i.pc)(e,t),eo=n._sqlite3_bind_blob=(e,t,r,_,o)=>(eo=n._sqlite3_bind_blob=i.qc)(e,t,r,_,o),to=n._sqlite3_bind_blob64=(e,t,r,_,o,a)=>(to=n._sqlite3_bind_blob64=i.rc)(e,t,r,_,o,a),ro=n._sqlite3_bind_double=(e,t,r)=>(ro=n._sqlite3_bind_double=i.sc)(e,t,r),no=n._sqlite3_bind_int=(e,t,r)=>(no=n._sqlite3_bind_int=i.tc)(e,t,r),_o=n._sqlite3_bind_int64=(e,t,r,_)=>(_o=n._sqlite3_bind_int64=i.uc)(e,t,r,_),so=n._sqlite3_bind_null=(e,t)=>(so=n._sqlite3_bind_null=i.vc)(e,t),oo=n._sqlite3_bind_pointer=(e,t,r,_,o)=>(oo=n._sqlite3_bind_pointer=i.wc)(e,t,r,_,o),io=n._sqlite3_bind_text=(e,t,r,_,o)=>(io=n._sqlite3_bind_text=i.xc)(e,t,r,_,o),ao=n._sqlite3_bind_text64=(e,t,r,_,o,a,l)=>(ao=n._sqlite3_bind_text64=i.yc)(e,t,r,_,o,a,l),lo=n._sqlite3_bind_text16=(e,t,r,_,o)=>(lo=n._sqlite3_bind_text16=i.zc)(e,t,r,_,o),co=n._sqlite3_bind_value=(e,t,r)=>(co=n._sqlite3_bind_value=i.Ac)(e,t,r),uo=n._sqlite3_bind_zeroblob=(e,t,r)=>(uo=n._sqlite3_bind_zeroblob=i.Bc)(e,t,r),fo=n._sqlite3_bind_zeroblob64=(e,t,r,_)=>(fo=n._sqlite3_bind_zeroblob64=i.Cc)(e,t,r,_),po=n._sqlite3_bind_parameter_count=e=>(po=n._sqlite3_bind_parameter_count=i.Dc)(e),vo=n._sqlite3_bind_parameter_name=(e,t)=>(vo=n._sqlite3_bind_parameter_name=i.Ec)(e,t),mo=n._sqlite3_bind_parameter_index=(e,t)=>(mo=n._sqlite3_bind_parameter_index=i.Fc)(e,t),Eo=n._sqlite3_db_handle=e=>(Eo=n._sqlite3_db_handle=i.Gc)(e),qo=n._sqlite3_stmt_readonly=e=>(qo=n._sqlite3_stmt_readonly=i.Hc)(e),ho=n._sqlite3_stmt_isexplain=e=>(ho=n._sqlite3_stmt_isexplain=i.Ic)(e),bo=n._sqlite3_stmt_explain=(e,t)=>(bo=n._sqlite3_stmt_explain=i.Jc)(e,t),To=n._sqlite3_stmt_busy=e=>(To=n._sqlite3_stmt_busy=i.Kc)(e),wo=n._sqlite3_next_stmt=(e,t)=>(wo=n._sqlite3_next_stmt=i.Lc)(e,t),yo=n._sqlite3_stmt_status=(e,t,r)=>(yo=n._sqlite3_stmt_status=i.Mc)(e,t,r),So=n._sqlite3_sql=e=>(So=n._sqlite3_sql=i.Nc)(e),go=n._sqlite3_expanded_sql=e=>(go=n._sqlite3_expanded_sql=i.Oc)(e),Io=n._sqlite3_value_numeric_type=e=>(Io=n._sqlite3_value_numeric_type=i.Pc)(e),Lo=n._sqlite3_blob_open=(e,t,r,_,o,a,l,c)=>(Lo=n._sqlite3_blob_open=i.Qc)(e,t,r,_,o,a,l,c),xo=n._sqlite3_blob_close=e=>(xo=n._sqlite3_blob_close=i.Rc)(e),Ao=n._sqlite3_blob_read=(e,t,r,_)=>(Ao=n._sqlite3_blob_read=i.Sc)(e,t,r,_),No=n._sqlite3_blob_write=(e,t,r,_)=>(No=n._sqlite3_blob_write=i.Tc)(e,t,r,_),Ro=n._sqlite3_blob_bytes=e=>(Ro=n._sqlite3_blob_bytes=i.Uc)(e),ko=n._sqlite3_blob_reopen=(e,t,r)=>(ko=n._sqlite3_blob_reopen=i.Vc)(e,t,r),Oo=n._sqlite3_set_authorizer=(e,t,r)=>(Oo=n._sqlite3_set_authorizer=i.Wc)(e,t,r),Qo=n._sqlite3_strglob=(e,t)=>(Qo=n._sqlite3_strglob=i.Xc)(e,t),Co=n._sqlite3_strlike=(e,t,r)=>(Co=n._sqlite3_strlike=i.Yc)(e,t,r),Fo=n._sqlite3_errmsg=e=>(Fo=n._sqlite3_errmsg=i.Zc)(e),Po=n._sqlite3_auto_extension=e=>(Po=n._sqlite3_auto_extension=i._c)(e),Do=n._sqlite3_cancel_auto_extension=e=>(Do=n._sqlite3_cancel_auto_extension=i.$c)(e),Mo=n._sqlite3_reset_auto_extension=()=>(Mo=n._sqlite3_reset_auto_extension=i.ad)(),Uo=n._sqlite3_prepare=(e,t,r,_,o)=>(Uo=n._sqlite3_prepare=i.bd)(e,t,r,_,o),zo=n._sqlite3_prepare_v3=(e,t,r,_,o,a)=>(zo=n._sqlite3_prepare_v3=i.cd)(e,t,r,_,o,a),Bo=n._sqlite3_prepare16=(e,t,r,_,o)=>(Bo=n._sqlite3_prepare16=i.dd)(e,t,r,_,o),Ho=n._sqlite3_prepare16_v2=(e,t,r,_,o)=>(Ho=n._sqlite3_prepare16_v2=i.ed)(e,t,r,_,o),Wo=n._sqlite3_prepare16_v3=(e,t,r,_,o,a)=>(Wo=n._sqlite3_prepare16_v3=i.fd)(e,t,r,_,o,a),jo=n._sqlite3_get_table=(e,t,r,_,o,a)=>(jo=n._sqlite3_get_table=i.gd)(e,t,r,_,o,a),Go=n._sqlite3_free_table=e=>(Go=n._sqlite3_free_table=i.hd)(e),Ko=n._sqlite3_create_module=(e,t,r,_)=>(Ko=n._sqlite3_create_module=i.id)(e,t,r,_),Vo=n._sqlite3_create_module_v2=(e,t,r,_,o)=>(Vo=n._sqlite3_create_module_v2=i.jd)(e,t,r,_,o),Xo=n._sqlite3_drop_modules=(e,t)=>(Xo=n._sqlite3_drop_modules=i.kd)(e,t),Yo=n._sqlite3_declare_vtab=(e,t)=>(Yo=n._sqlite3_declare_vtab=i.ld)(e,t),$o=n._sqlite3_vtab_on_conflict=e=>($o=n._sqlite3_vtab_on_conflict=i.md)(e),Zo=n._sqlite3_vtab_config=(e,t,r)=>(Zo=n._sqlite3_vtab_config=i.nd)(e,t,r),Jo=n._sqlite3_vtab_collation=(e,t)=>(Jo=n._sqlite3_vtab_collation=i.od)(e,t),ei=n._sqlite3_vtab_in=(e,t,r)=>(ei=n._sqlite3_vtab_in=i.pd)(e,t,r),ti=n._sqlite3_vtab_rhs_value=(e,t,r)=>(ti=n._sqlite3_vtab_rhs_value=i.qd)(e,t,r),ri=n._sqlite3_vtab_distinct=e=>(ri=n._sqlite3_vtab_distinct=i.rd)(e),ni=n._sqlite3_keyword_name=(e,t,r)=>(ni=n._sqlite3_keyword_name=i.sd)(e,t,r),_i=n._sqlite3_keyword_count=()=>(_i=n._sqlite3_keyword_count=i.td)(),si=n._sqlite3_keyword_check=(e,t)=>(si=n._sqlite3_keyword_check=i.ud)(e,t),oi=n._sqlite3_complete=e=>(oi=n._sqlite3_complete=i.vd)(e),ii=n._sqlite3_complete16=e=>(ii=n._sqlite3_complete16=i.wd)(e),ai=n._sqlite3_libversion=()=>(ai=n._sqlite3_libversion=i.xd)(),li=n._sqlite3_libversion_number=()=>(li=n._sqlite3_libversion_number=i.yd)(),ci=n._sqlite3_threadsafe=()=>(ci=n._sqlite3_threadsafe=i.zd)(),ui=n._sqlite3_initialize=()=>(ui=n._sqlite3_initialize=i.Ad)(),fi=n._sqlite3_shutdown=()=>(fi=n._sqlite3_shutdown=i.Bd)(),di=n._sqlite3_config=(e,t)=>(di=n._sqlite3_config=i.Cd)(e,t),pi=n._sqlite3_db_mutex=e=>(pi=n._sqlite3_db_mutex=i.Dd)(e),vi=n._sqlite3_db_release_memory=e=>(vi=n._sqlite3_db_release_memory=i.Ed)(e),mi=n._sqlite3_db_cacheflush=e=>(mi=n._sqlite3_db_cacheflush=i.Fd)(e),Ei=n._sqlite3_db_config=(e,t,r)=>(Ei=n._sqlite3_db_config=i.Gd)(e,t,r),qi=n._sqlite3_last_insert_rowid=e=>(qi=n._sqlite3_last_insert_rowid=i.Hd)(e),hi=n._sqlite3_set_last_insert_rowid=(e,t,r)=>(hi=n._sqlite3_set_last_insert_rowid=i.Id)(e,t,r),bi=n._sqlite3_changes64=e=>(bi=n._sqlite3_changes64=i.Jd)(e),Ti=n._sqlite3_changes=e=>(Ti=n._sqlite3_changes=i.Kd)(e),wi=n._sqlite3_total_changes64=e=>(wi=n._sqlite3_total_changes64=i.Ld)(e),yi=n._sqlite3_total_changes=e=>(yi=n._sqlite3_total_changes=i.Md)(e),Si=n._sqlite3_txn_state=(e,t)=>(Si=n._sqlite3_txn_state=i.Nd)(e,t),gi=n._sqlite3_close=e=>(gi=n._sqlite3_close=i.Od)(e),Ii=n._sqlite3_close_v2=e=>(Ii=n._sqlite3_close_v2=i.Pd)(e),Li=n._sqlite3_busy_handler=(e,t,r)=>(Li=n._sqlite3_busy_handler=i.Qd)(e,t,r),xi=n._sqlite3_progress_handler=(e,t,r,_)=>(xi=n._sqlite3_progress_handler=i.Rd)(e,t,r,_),Ai=n._sqlite3_busy_timeout=(e,t)=>(Ai=n._sqlite3_busy_timeout=i.Sd)(e,t),Ni=n._sqlite3_interrupt=e=>(Ni=n._sqlite3_interrupt=i.Td)(e),Ri=n._sqlite3_is_interrupted=e=>(Ri=n._sqlite3_is_interrupted=i.Ud)(e),ki=n._sqlite3_create_function=(e,t,r,_,o,a,l,c)=>(ki=n._sqlite3_create_function=i.Vd)(e,t,r,_,o,a,l,c),Oi=n._sqlite3_create_function_v2=(e,t,r,_,o,a,l,c,E)=>(Oi=n._sqlite3_create_function_v2=i.Wd)(e,t,r,_,o,a,l,c,E),Qi=n._sqlite3_create_window_function=(e,t,r,_,o,a,l,c,E,h)=>(Qi=n._sqlite3_create_window_function=i.Xd)(e,t,r,_,o,a,l,c,E,h),Ci=n._sqlite3_create_function16=(e,t,r,_,o,a,l,c)=>(Ci=n._sqlite3_create_function16=i.Yd)(e,t,r,_,o,a,l,c),Fi=n._sqlite3_overload_function=(e,t,r)=>(Fi=n._sqlite3_overload_function=i.Zd)(e,t,r),Pi=n._sqlite3_trace_v2=(e,t,r,_)=>(Pi=n._sqlite3_trace_v2=i._d)(e,t,r,_),Di=n._sqlite3_commit_hook=(e,t,r)=>(Di=n._sqlite3_commit_hook=i.$d)(e,t,r),Mi=n._sqlite3_update_hook=(e,t,r)=>(Mi=n._sqlite3_update_hook=i.ae)(e,t,r),Ui=n._sqlite3_rollback_hook=(e,t,r)=>(Ui=n._sqlite3_rollback_hook=i.be)(e,t,r),zi=n._sqlite3_autovacuum_pages=(e,t,r,_)=>(zi=n._sqlite3_autovacuum_pages=i.ce)(e,t,r,_),Bi=n._sqlite3_wal_autocheckpoint=(e,t)=>(Bi=n._sqlite3_wal_autocheckpoint=i.de)(e,t),Hi=n._sqlite3_wal_hook=(e,t,r)=>(Hi=n._sqlite3_wal_hook=i.ee)(e,t,r),Wi=n._sqlite3_wal_checkpoint_v2=(e,t,r,_,o)=>(Wi=n._sqlite3_wal_checkpoint_v2=i.fe)(e,t,r,_,o),ji=n._sqlite3_wal_checkpoint=(e,t)=>(ji=n._sqlite3_wal_checkpoint=i.ge)(e,t),Gi=n._sqlite3_error_offset=e=>(Gi=n._sqlite3_error_offset=i.he)(e),Ki=n._sqlite3_errmsg16=e=>(Ki=n._sqlite3_errmsg16=i.ie)(e),Vi=n._sqlite3_errcode=e=>(Vi=n._sqlite3_errcode=i.je)(e),Xi=n._sqlite3_extended_errcode=e=>(Xi=n._sqlite3_extended_errcode=i.ke)(e),Yi=n._sqlite3_system_errno=e=>(Yi=n._sqlite3_system_errno=i.le)(e),$i=n._sqlite3_errstr=e=>($i=n._sqlite3_errstr=i.me)(e),Zi=n._sqlite3_limit=(e,t,r)=>(Zi=n._sqlite3_limit=i.ne)(e,t,r),Ji=n._sqlite3_open=(e,t)=>(Ji=n._sqlite3_open=i.oe)(e,t),ea=n._sqlite3_open_v2=(e,t,r,_)=>(ea=n._sqlite3_open_v2=i.pe)(e,t,r,_),ta=n._sqlite3_open16=(e,t)=>(ta=n._sqlite3_open16=i.qe)(e,t),ra=n._sqlite3_create_collation=(e,t,r,_,o)=>(ra=n._sqlite3_create_collation=i.re)(e,t,r,_,o),na=n._sqlite3_create_collation_v2=(e,t,r,_,o,a)=>(na=n._sqlite3_create_collation_v2=i.se)(e,t,r,_,o,a),_a=n._sqlite3_create_collation16=(e,t,r,_,o)=>(_a=n._sqlite3_create_collation16=i.te)(e,t,r,_,o),sa=n._sqlite3_collation_needed=(e,t,r)=>(sa=n._sqlite3_collation_needed=i.ue)(e,t,r),oa=n._sqlite3_collation_needed16=(e,t,r)=>(oa=n._sqlite3_collation_needed16=i.ve)(e,t,r),ia=n._sqlite3_get_clientdata=(e,t)=>(ia=n._sqlite3_get_clientdata=i.we)(e,t),aa=n._sqlite3_set_clientdata=(e,t,r,_)=>(aa=n._sqlite3_set_clientdata=i.xe)(e,t,r,_),la=n._sqlite3_get_autocommit=e=>(la=n._sqlite3_get_autocommit=i.ye)(e),ca=n._sqlite3_table_column_metadata=(e,t,r,_,o,a,l,c,E)=>(ca=n._sqlite3_table_column_metadata=i.ze)(e,t,r,_,o,a,l,c,E),ua=n._sqlite3_sleep=e=>(ua=n._sqlite3_sleep=i.Ae)(e),fa=n._sqlite3_extended_result_codes=(e,t)=>(fa=n._sqlite3_extended_result_codes=i.Be)(e,t),da=n._sqlite3_file_control=(e,t,r,_)=>(da=n._sqlite3_file_control=i.Ce)(e,t,r,_),pa=n._sqlite3_test_control=(e,t)=>(pa=n._sqlite3_test_control=i.De)(e,t),va=n._sqlite3_create_filename=(e,t,r,_,o)=>(va=n._sqlite3_create_filename=i.Ee)(e,t,r,_,o),ma=n._sqlite3_free_filename=e=>(ma=n._sqlite3_free_filename=i.Fe)(e),Ea=n._sqlite3_uri_parameter=(e,t)=>(Ea=n._sqlite3_uri_parameter=i.Ge)(e,t),qa=n._sqlite3_uri_key=(e,t)=>(qa=n._sqlite3_uri_key=i.He)(e,t),ha=n._sqlite3_uri_boolean=(e,t,r)=>(ha=n._sqlite3_uri_boolean=i.Ie)(e,t,r),ba=n._sqlite3_uri_int64=(e,t,r,_)=>(ba=n._sqlite3_uri_int64=i.Je)(e,t,r,_),Ta=n._sqlite3_filename_database=e=>(Ta=n._sqlite3_filename_database=i.Ke)(e),wa=n._sqlite3_filename_journal=e=>(wa=n._sqlite3_filename_journal=i.Le)(e),ya=n._sqlite3_filename_wal=e=>(ya=n._sqlite3_filename_wal=i.Me)(e),Sa=n._sqlite3_db_name=(e,t)=>(Sa=n._sqlite3_db_name=i.Ne)(e,t),ga=n._sqlite3_db_filename=(e,t)=>(ga=n._sqlite3_db_filename=i.Oe)(e,t),Ia=n._sqlite3_db_readonly=(e,t)=>(Ia=n._sqlite3_db_readonly=i.Pe)(e,t),La=n._sqlite3_compileoption_used=e=>(La=n._sqlite3_compileoption_used=i.Qe)(e),xa=n._sqlite3_compileoption_get=e=>(xa=n._sqlite3_compileoption_get=i.Re)(e),Aa=n._sqlite3_sourceid=()=>(Aa=n._sqlite3_sourceid=i.Se)(),Na=n._malloc=e=>(Na=n._malloc=i.Te)(e),Ra=n._free=e=>(Ra=n._free=i.Ue)(e),ka=n._RegisterExtensionFunctions=e=>(ka=n._RegisterExtensionFunctions=i.Ve)(e),Oa=n._getSqliteFree=()=>(Oa=n._getSqliteFree=i.We)(),ct=n._main=(e,t)=>(ct=n._main=i.Xe)(e,t),Qa=n._libauthorizer_set_authorizer=(e,t,r)=>(Qa=n._libauthorizer_set_authorizer=i.Ye)(e,t,r),Ca=n._libfunction_create_function=(e,t,r,_,o,a,l,c)=>(Ca=n._libfunction_create_function=i.Ze)(e,t,r,_,o,a,l,c),Fa=n._libprogress_progress_handler=(e,t,r,_)=>(Fa=n._libprogress_progress_handler=i._e)(e,t,r,_),Pa=n._libvfs_vfs_register=(e,t,r,_,o,a)=>(Pa=n._libvfs_vfs_register=i.$e)(e,t,r,_,o,a),ut=(e,t)=>(ut=i.bf)(e,t),ft=()=>(ft=i.cf)(),dt=e=>(dt=i.df)(e),pt=e=>(pt=i.ef)(e),vt=()=>(vt=i.ff)(),Va=n._sqlite3_version=5472;n.getTempRet0=Un,n.ccall=Ee,n.cwrap=Mn,n.addFunction=Pn,n.setValue=Ae,n.getValue=$e,n.UTF8ToString=ce,n.stringToUTF8=oe,n.lengthBytesUTF8=pe,n.intArrayFromString=Me,n.intArrayToString=Gn,n.AsciiToString=Hn,n.UTF16ToString=Wn,n.stringToUTF16=zn,n.UTF32ToString=jn,n.stringToUTF32=Bn,n.writeArrayToMemory=it;var Re;be=function e(){Re||mt(),Re||(be=e)};function Da(){var e=ct,t=0,r=0;try{var _=e(t,r);return xn(_,!0),_}catch(o){return An(o)}}function mt(){if(le>0||(Ot(),le>0))return;function e(){Re||(Re=!0,n.calledRun=!0,!W&&(Qt(),Ct(),ie(n),n.onRuntimeInitialized?.(),Et&&Da(),Ft()))}n.setStatus?(n.setStatus("Running..."),setTimeout(function(){setTimeout(function(){n.setStatus("")},1),e()},1)):e()}if(n.preInit)for(typeof n.preInit=="function"&&(n.preInit=[n.preInit]);n.preInit.length>0;)n.preInit.pop()();var Et=!0;return n.noInitialRun&&(Et=!1),mt(),function(){let e=Object.getPrototypeOf(async function(){}).constructor,t=0;n.set_authorizer=function(r,_,o){t&&(n.deleteCallback(t),n._sqlite3_free(t),t=0),t=n._sqlite3_malloc(4),Ae(t,_ instanceof e?1:0,"i32");let a=Ee("libauthorizer_set_authorizer","number",["number","number","number"],[r,_?1:0,t]);return!a&&_&&n.setCallback(t,(l,c,E,h,g,A)=>_(o,c,E,h,g,A)),a}}(),function(){let e=Object.getPrototypeOf(async function(){}).constructor,t=["xFunc","xStep","xFinal"],r=new Map;n.create_function=function(_,o,a,l,c,E,h,g){let A=n._sqlite3_malloc(4),x={xFunc:E,xStep:h,xFinal:g};Ae(A,t.reduce((b,M,V)=>x[M]instanceof e?b|1<o(a))}}(),function(){let e=["xOpen","xDelete","xAccess","xFullPathname","xRandomness","xSleep","xCurrentTime","xGetLastError","xCurrentTimeInt64","xClose","xRead","xWrite","xTruncate","xSync","xFileSize","xLock","xUnlock","xCheckReservedLock","xFileControl","xSectorSize","xDeviceCharacteristics","xShmMap","xShmLock","xShmBarrier","xShmUnmap"],t=new Map;n.vfs_register=function(r,_){let o=0,a=0;e.forEach((c,E)=>{r[c]&&(o|=1< Date: Mon, 22 Jul 2024 13:55:09 -0500 Subject: [PATCH 07/28] WIP --- bindings_node/Cargo.lock | 21 +- diesel-wasm-sqlite/.gitignore | 8 + diesel-wasm-sqlite/.yarnrc.yml | 7 + diesel-wasm-sqlite/esbuild.js | 13 - diesel-wasm-sqlite/package-lock.json | 433 ------- diesel-wasm-sqlite/package.js | 2 - diesel-wasm-sqlite/package.json | 21 +- diesel-wasm-sqlite/rollup.config.js | 25 + diesel-wasm-sqlite/src/package.js | 952 ++++++++++++++- diesel-wasm-sqlite/src/wa-sqlite.wasm | Bin 0 -> 595455 bytes diesel-wasm-sqlite/tests/web.rs | 2 +- diesel-wasm-sqlite/yarn.lock | 1603 +++++++++++++++++++++++++ 12 files changed, 2614 insertions(+), 473 deletions(-) create mode 100644 diesel-wasm-sqlite/.gitignore create mode 100644 diesel-wasm-sqlite/.yarnrc.yml delete mode 100644 diesel-wasm-sqlite/esbuild.js delete mode 100644 diesel-wasm-sqlite/package-lock.json create mode 100644 diesel-wasm-sqlite/rollup.config.js create mode 100755 diesel-wasm-sqlite/src/wa-sqlite.wasm create mode 100644 diesel-wasm-sqlite/yarn.lock diff --git a/bindings_node/Cargo.lock b/bindings_node/Cargo.lock index d50511cea..1592fc463 100644 --- a/bindings_node/Cargo.lock +++ b/bindings_node/Cargo.lock @@ -846,8 +846,7 @@ dependencies = [ [[package]] name = "diesel" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35b696af9ff4c0d2a507db2c5faafa8aa0205e297e5f11e203a24226d5355e7a" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "diesel_derives", "libsqlite3-sys", @@ -858,8 +857,7 @@ dependencies = [ [[package]] name = "diesel_derives" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d6fdd83d5947068817016e939596d246e5367279453f2a3433287894f2f2996" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "diesel_table_macro_syntax", "dsl_auto_type", @@ -871,8 +869,7 @@ dependencies = [ [[package]] name = "diesel_migrations" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a73ce704bad4231f001bff3314d91dce4aba0770cee8b233991859abc15c1f6" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "diesel", "migrations_internals", @@ -882,8 +879,7 @@ dependencies = [ [[package]] name = "diesel_table_macro_syntax" version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "syn 2.0.64", ] @@ -945,8 +941,7 @@ dependencies = [ [[package]] name = "dsl_auto_type" version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab32c18ea6760d951659768a3e35ea72fc1ba0916d665a88dfe048b2a41e543f" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "darling", "either", @@ -2429,8 +2424,7 @@ checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d" [[package]] name = "migrations_internals" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd01039851e82f8799046eabbb354056283fb265c8ec0996af940f4e85a380ff" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "serde", "toml", @@ -2439,8 +2433,7 @@ dependencies = [ [[package]] name = "migrations_macros" version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ffb161cc72176cb37aa47f1fc520d3ef02263d67d661f44f05d05a079e1237fd" +source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ "migrations_internals", "proc-macro2", diff --git a/diesel-wasm-sqlite/.gitignore b/diesel-wasm-sqlite/.gitignore new file mode 100644 index 000000000..f93dc9153 --- /dev/null +++ b/diesel-wasm-sqlite/.gitignore @@ -0,0 +1,8 @@ +# yarn +.pnp.* +.yarn/* +!.yarn/patches +!.yarn/plugins +!.yarn/releases +!.yarn/sdks +!.yarn/versions diff --git a/diesel-wasm-sqlite/.yarnrc.yml b/diesel-wasm-sqlite/.yarnrc.yml new file mode 100644 index 000000000..77ffe90a8 --- /dev/null +++ b/diesel-wasm-sqlite/.yarnrc.yml @@ -0,0 +1,7 @@ +compressionLevel: mixed + +enableGlobalCache: false + +enableTelemetry: false + +nodeLinker: node-modules diff --git a/diesel-wasm-sqlite/esbuild.js b/diesel-wasm-sqlite/esbuild.js deleted file mode 100644 index d85602232..000000000 --- a/diesel-wasm-sqlite/esbuild.js +++ /dev/null @@ -1,13 +0,0 @@ -const esbuild = require("esbuild"); -const { wasmLoader } = require("esbuild-plugin-wasm"); - -esbuild.build({ - entryPoints: ["package.js"], - bundle: true, - outfile: "src/package.js", - plugins: [ - wasmLoader(), - ], - format: "esm", - minify: true, -}).catch(() => process.exit(1)); diff --git a/diesel-wasm-sqlite/package-lock.json b/diesel-wasm-sqlite/package-lock.json deleted file mode 100644 index d592b6d5b..000000000 --- a/diesel-wasm-sqlite/package-lock.json +++ /dev/null @@ -1,433 +0,0 @@ -{ - "name": "diesel-wasm-sqlite", - "version": "1.0.0", - "lockfileVersion": 3, - "requires": true, - "packages": { - "": { - "name": "diesel-wasm-sqlite", - "version": "1.0.0", - "license": "ISC", - "dependencies": { - "@xmtp/wa-sqlite": "^1.0.1", - "esbuild": "^0.23.0", - "esbuild-plugin-wasm": "^1.1.0" - } - }, - "node_modules/@esbuild/aix-ppc64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.23.0.tgz", - "integrity": "sha512-3sG8Zwa5fMcA9bgqB8AfWPQ+HFke6uD3h1s3RIwUNK8EG7a4buxvuFTs3j1IMs2NXAk9F30C/FF4vxRgQCcmoQ==", - "cpu": [ - "ppc64" - ], - "optional": true, - "os": [ - "aix" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.23.0.tgz", - "integrity": "sha512-+KuOHTKKyIKgEEqKbGTK8W7mPp+hKinbMBeEnNzjJGyFcWsfrXjSTNluJHCY1RqhxFurdD8uNXQDei7qDlR6+g==", - "cpu": [ - "arm" - ], - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.23.0.tgz", - "integrity": "sha512-EuHFUYkAVfU4qBdyivULuu03FhJO4IJN9PGuABGrFy4vUuzk91P2d+npxHcFdpUnfYKy0PuV+n6bKIpHOB3prQ==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/android-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.23.0.tgz", - "integrity": "sha512-WRrmKidLoKDl56LsbBMhzTTBxrsVwTKdNbKDalbEZr0tcsBgCLbEtoNthOW6PX942YiYq8HzEnb4yWQMLQuipQ==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "android" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.23.0.tgz", - "integrity": "sha512-YLntie/IdS31H54Ogdn+v50NuoWF5BDkEUFpiOChVa9UnKpftgwzZRrI4J132ETIi+D8n6xh9IviFV3eXdxfow==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.23.0.tgz", - "integrity": "sha512-IMQ6eme4AfznElesHUPDZ+teuGwoRmVuuixu7sv92ZkdQcPbsNHzutd+rAfaBKo8YK3IrBEi9SLLKWJdEvJniQ==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.23.0.tgz", - "integrity": "sha512-0muYWCng5vqaxobq6LB3YNtevDFSAZGlgtLoAc81PjUfiFz36n4KMpwhtAd4he8ToSI3TGyuhyx5xmiWNYZFyw==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.23.0.tgz", - "integrity": "sha512-XKDVu8IsD0/q3foBzsXGt/KjD/yTKBCIwOHE1XwiXmrRwrX6Hbnd5Eqn/WvDekddK21tfszBSrE/WMaZh+1buQ==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.23.0.tgz", - "integrity": "sha512-SEELSTEtOFu5LPykzA395Mc+54RMg1EUgXP+iw2SJ72+ooMwVsgfuwXo5Fn0wXNgWZsTVHwY2cg4Vi/bOD88qw==", - "cpu": [ - "arm" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.23.0.tgz", - "integrity": "sha512-j1t5iG8jE7BhonbsEg5d9qOYcVZv/Rv6tghaXM/Ug9xahM0nX/H2gfu6X6z11QRTMT6+aywOMA8TDkhPo8aCGw==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ia32": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.23.0.tgz", - "integrity": "sha512-P7O5Tkh2NbgIm2R6x1zGJJsnacDzTFcRWZyTTMgFdVit6E98LTxO+v8LCCLWRvPrjdzXHx9FEOA8oAZPyApWUA==", - "cpu": [ - "ia32" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-loong64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.23.0.tgz", - "integrity": "sha512-InQwepswq6urikQiIC/kkx412fqUZudBO4SYKu0N+tGhXRWUqAx+Q+341tFV6QdBifpjYgUndV1hhMq3WeJi7A==", - "cpu": [ - "loong64" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-mips64el": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.23.0.tgz", - "integrity": "sha512-J9rflLtqdYrxHv2FqXE2i1ELgNjT+JFURt/uDMoPQLcjWQA5wDKgQA4t/dTqGa88ZVECKaD0TctwsUfHbVoi4w==", - "cpu": [ - "mips64el" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ppc64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.23.0.tgz", - "integrity": "sha512-cShCXtEOVc5GxU0fM+dsFD10qZ5UpcQ8AM22bYj0u/yaAykWnqXJDpd77ublcX6vdDsWLuweeuSNZk4yUxZwtw==", - "cpu": [ - "ppc64" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-riscv64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.23.0.tgz", - "integrity": "sha512-HEtaN7Y5UB4tZPeQmgz/UhzoEyYftbMXrBCUjINGjh3uil+rB/QzzpMshz3cNUxqXN7Vr93zzVtpIDL99t9aRw==", - "cpu": [ - "riscv64" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-s390x": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.23.0.tgz", - "integrity": "sha512-WDi3+NVAuyjg/Wxi+o5KPqRbZY0QhI9TjrEEm+8dmpY9Xir8+HE/HNx2JoLckhKbFopW0RdO2D72w8trZOV+Wg==", - "cpu": [ - "s390x" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.23.0.tgz", - "integrity": "sha512-a3pMQhUEJkITgAw6e0bWA+F+vFtCciMjW/LPtoj99MhVt+Mfb6bbL9hu2wmTZgNd994qTAEw+U/r6k3qHWWaOQ==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.23.0.tgz", - "integrity": "sha512-cRK+YDem7lFTs2Q5nEv/HHc4LnrfBCbH5+JHu6wm2eP+d8OZNoSMYgPZJq78vqQ9g+9+nMuIsAO7skzphRXHyw==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.23.0.tgz", - "integrity": "sha512-suXjq53gERueVWu0OKxzWqk7NxiUWSUlrxoZK7usiF50C6ipColGR5qie2496iKGYNLhDZkPxBI3erbnYkU0rQ==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.23.0.tgz", - "integrity": "sha512-6p3nHpby0DM/v15IFKMjAaayFhqnXV52aEmv1whZHX56pdkK+MEaLoQWj+H42ssFarP1PcomVhbsR4pkz09qBg==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/sunos-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.23.0.tgz", - "integrity": "sha512-BFelBGfrBwk6LVrmFzCq1u1dZbG4zy/Kp93w2+y83Q5UGYF1d8sCzeLI9NXjKyujjBBniQa8R8PzLFAUrSM9OA==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "sunos" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-arm64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.23.0.tgz", - "integrity": "sha512-lY6AC8p4Cnb7xYHuIxQ6iYPe6MfO2CC43XXKo9nBXDb35krYt7KGhQnOkRGar5psxYkircpCqfbNDB4uJbS2jQ==", - "cpu": [ - "arm64" - ], - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-ia32": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.23.0.tgz", - "integrity": "sha512-7L1bHlOTcO4ByvI7OXVI5pNN6HSu6pUQq9yodga8izeuB1KcT2UkHaH6118QJwopExPn0rMHIseCTx1CRo/uNA==", - "cpu": [ - "ia32" - ], - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-x64": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.23.0.tgz", - "integrity": "sha512-Arm+WgUFLUATuoxCJcahGuk6Yj9Pzxd6l11Zb/2aAuv5kWWvvfhLFo2fni4uSK5vzlUdCGZ/BdV5tH8klj8p8g==", - "cpu": [ - "x64" - ], - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@xmtp/wa-sqlite": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/@xmtp/wa-sqlite/-/wa-sqlite-1.0.1.tgz", - "integrity": "sha512-/MVsgo5HG7FVdMMNUKsf5HTIDnOncSK0ljrOBr+xqkfH6qonQwqmUsjcW2Z4GyyCIVvhQlxOSy+1W+7Z/WH0DA==" - }, - "node_modules/esbuild": { - "version": "0.23.0", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.23.0.tgz", - "integrity": "sha512-1lvV17H2bMYda/WaFb2jLPeHU3zml2k4/yagNMG8Q/YtfMjCwEUZa2eXXMgZTVSL5q1n4H7sQ0X6CdJDqqeCFA==", - "hasInstallScript": true, - "bin": { - "esbuild": "bin/esbuild" - }, - "engines": { - "node": ">=18" - }, - "optionalDependencies": { - "@esbuild/aix-ppc64": "0.23.0", - "@esbuild/android-arm": "0.23.0", - "@esbuild/android-arm64": "0.23.0", - "@esbuild/android-x64": "0.23.0", - "@esbuild/darwin-arm64": "0.23.0", - "@esbuild/darwin-x64": "0.23.0", - "@esbuild/freebsd-arm64": "0.23.0", - "@esbuild/freebsd-x64": "0.23.0", - "@esbuild/linux-arm": "0.23.0", - "@esbuild/linux-arm64": "0.23.0", - "@esbuild/linux-ia32": "0.23.0", - "@esbuild/linux-loong64": "0.23.0", - "@esbuild/linux-mips64el": "0.23.0", - "@esbuild/linux-ppc64": "0.23.0", - "@esbuild/linux-riscv64": "0.23.0", - "@esbuild/linux-s390x": "0.23.0", - "@esbuild/linux-x64": "0.23.0", - "@esbuild/netbsd-x64": "0.23.0", - "@esbuild/openbsd-arm64": "0.23.0", - "@esbuild/openbsd-x64": "0.23.0", - "@esbuild/sunos-x64": "0.23.0", - "@esbuild/win32-arm64": "0.23.0", - "@esbuild/win32-ia32": "0.23.0", - "@esbuild/win32-x64": "0.23.0" - } - }, - "node_modules/esbuild-plugin-wasm": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/esbuild-plugin-wasm/-/esbuild-plugin-wasm-1.1.0.tgz", - "integrity": "sha512-0bQ6+1tUbySSnxzn5jnXHMDvYnT0cN/Wd4Syk8g/sqAIJUg7buTIi22svS3Qz6ssx895NT+TgLPb33xi1OkZig==", - "engines": { - "node": ">=0.10.0" - }, - "funding": { - "type": "individual", - "url": "https://ko-fi.com/tschrock" - } - } - } -} diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index 0f738e93a..42a0603ba 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -3,8 +3,6 @@ import initModule from "@xmtp/wa-sqlite/build"; const module = await initModule(); const sqlite3 = SQLite.Factory(module); -const vfs = await OPFSCoopSyncVFS.create("test", module); -sqlite3.vfs_register(vfs, true); export function sqlite3_result_text(context, value) { sqlite3.result_text(context, value); diff --git a/diesel-wasm-sqlite/package.json b/diesel-wasm-sqlite/package.json index 196f0c535..7fee0b676 100644 --- a/diesel-wasm-sqlite/package.json +++ b/diesel-wasm-sqlite/package.json @@ -1,17 +1,22 @@ { "name": "diesel-wasm-sqlite", + "type": "module", "version": "1.0.0", "description": "", - "main": "esbuild.js", + "main": "package.js", "scripts": { - "test": "echo \"Error: no test specified\" && exit 1", - "esbuild": "node esbuild.js" + "build": "rollup -c" }, - "author": "", - "license": "ISC", "dependencies": { - "@xmtp/wa-sqlite": "^1.0.1", - "esbuild": "^0.23.0", - "esbuild-plugin-wasm": "^1.1.0" + "@xmtp/wa-sqlite": "^1.0.1" + }, + "packageManager": "yarn@4.3.1", + "engines": { + "node": ">=20" + }, + "devDependencies": { + "@rollup/plugin-node-resolve": "^15.2.3", + "rollup": "^4.19.0", + "rollup-plugin-copy": "^3.5.0" } } diff --git a/diesel-wasm-sqlite/rollup.config.js b/diesel-wasm-sqlite/rollup.config.js new file mode 100644 index 000000000..a2ceba45a --- /dev/null +++ b/diesel-wasm-sqlite/rollup.config.js @@ -0,0 +1,25 @@ +import { defineConfig } from "rollup"; +import resolve from "@rollup/plugin-node-resolve"; +import copy from "rollup-plugin-copy"; + +export default defineConfig([ + { + input: "package.js", + output: { + file: "src/package.js", + format: "es", + }, + plugins: [ + resolve(), + copy({ + targets: [ + { + src: "node_modules/@xmtp/wa-sqlite/dist/wa-sqlite.wasm", + dest: "src", + }, + ], + }), + ], + // external: ["@xmtp/wa-sqlite", "@xmtp/wa-sqlite/build"], + }, +]); diff --git a/diesel-wasm-sqlite/src/package.js b/diesel-wasm-sqlite/src/package.js index 3be63470c..d8cedc13a 100644 --- a/diesel-wasm-sqlite/src/package.js +++ b/diesel-wasm-sqlite/src/package.js @@ -1,2 +1,950 @@ -var gt=0x7fffffffffffffffn,It=-0x8000000000000000n,Lt=Object.getPrototypeOf(async function(){}).constructor,ue=class extends Error{constructor(p,K){super(p),this.code=K}},Se=!0;function xt(m){let p={};m.retryOps=[];let K=m._getSqliteFree(),n=m._malloc(8),ie=[n,n+4];function re(d){if(typeof d!="string")return 0;let f=new TextEncoder().encode(d),u=m._sqlite3_malloc(f.byteLength+1);return m.HEAPU8.set(f,u),m.HEAPU8[u+f.byteLength]=0,u}function he(d,f){return BigInt(f)<<32n|BigInt(d)&0xffffffffn}let ge=function(){let d=BigInt(Number.MAX_SAFE_INTEGER)>>32n,f=BigInt(Number.MIN_SAFE_INTEGER)>>32n;return function(u,v){return v>d||v2147483647||q<-2147483648)return 25;let w=f(u,v,q);return B(d,w,G.get(u))}}(),p.bind_int64=function(){let d="sqlite3_bind_int64",f=m.cwrap(d,...I("nnnn:n"));return function(u,v,q){if(F(u),q>gt||q>32n,D=f(u,v,Number(w),Number(R));return B(d,D,G.get(u))}}(),p.bind_null=function(){let d="sqlite3_bind_null",f=m.cwrap(d,...I("nn:n"));return function(u,v){F(u);let q=f(u,v);return B(d,q,G.get(u))}}(),p.bind_parameter_name=function(){let f=m.cwrap("sqlite3_bind_parameter_name",...I("n:s"));return function(u,v){return F(u),f(u,v)}}(),p.bind_text=function(){let d="sqlite3_bind_text",f=m.cwrap(d,...I("nnnnn:n"));return function(u,v,q){F(u);let w=re(q),R=f(u,v,w,-1,K);return B(d,R,G.get(u))}}(),p.changes=function(){let f=m.cwrap("sqlite3_changes",...I("n:n"));return function(u){return fe(u),f(u)}}(),p.close=function(){let d="sqlite3_close",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){fe(u);let v=await f(u);return ne.delete(u),B(d,v,u)}}(),p.column=function(d,f){F(d);let u=p.column_type(d,f);switch(u){case 4:return p.column_blob(d,f);case 2:return p.column_double(d,f);case 1:let v=p.column_int(d,f),q=m.getTempRet0();return ge(v,q);case 5:return null;case 3:return p.column_text(d,f);default:throw new ue("unknown type",u)}},p.column_blob=function(){let f=m.cwrap("sqlite3_column_blob",...I("nn:n"));return function(u,v){F(u);let q=p.column_bytes(u,v),w=f(u,v);return m.HEAPU8.subarray(w,w+q)}}(),p.column_bytes=function(){let f=m.cwrap("sqlite3_column_bytes",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_count=function(){let f=m.cwrap("sqlite3_column_count",...I("n:n"));return function(u){return F(u),f(u)}}(),p.column_double=function(){let f=m.cwrap("sqlite3_column_double",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_int=function(){let f=m.cwrap("sqlite3_column_int64",...I("nn:n"));return function(u,v){return F(u),f(u,v)}}(),p.column_int64=function(){let f=m.cwrap("sqlite3_column_int64",...I("nn:n"));return function(u,v){F(u);let q=f(u,v),w=m.getTempRet0();return he(q,w)}}(),p.column_name=function(){let f=m.cwrap("sqlite3_column_name",...I("nn:s"));return function(u,v){return F(u),f(u,v)}}(),p.column_names=function(d){let f=[],u=p.column_count(d);for(let v=0;vk(C,m.HEAP32.subarray(Z/4,Z/4+U)):(C,U,Z)=>k(C,m.HEAP32.subarray(Z/4,Z/4+U))}let j=m.create_function(d,f,u,v,q,w&&W(w),R&&W(R),D);return B("sqlite3_create_function",j,d)},p.data_count=function(){let f=m.cwrap("sqlite3_data_count",...I("n:n"));return function(u){return F(u),f(u)}}(),p.exec=async function(d,f,u){for await(let v of p.statements(d,f)){let q;for(;await p.step(v)===100;)if(u){q=q??p.column_names(v);let w=p.row(v);await u(w,q)}}return 0},p.finalize=function(){let f=m.cwrap("sqlite3_finalize",...I("n:n"),{async:Se});return async function(u){let v=await f(u);return G.delete(u),v}}(),p.get_autocommit=function(){let f=m.cwrap("sqlite3_get_autocommit",...I("n:n"));return function(u){return f(u)}}(),p.libversion=function(){let f=m.cwrap("sqlite3_libversion",...I(":s"));return function(){return f()}}(),p.libversion_number=function(){let f=m.cwrap("sqlite3_libversion_number",...I(":n"));return function(){return f()}}(),p.limit=function(){let f=m.cwrap("sqlite3_limit",...I("nnn:n"));return function(u,v,q){return f(u,v,q)}}(),p.open_v2=function(){let d="sqlite3_open_v2",f=m.cwrap(d,...I("snnn:n"),{async:Se});return async function(u,v,q){v=v||6,q=re(q);try{let w=await ae(()=>f(u,ie[0],v,q)),R=m.getValue(ie[0],"*");return ne.add(R),m.ccall("RegisterExtensionFunctions","void",["number"],[R]),B(d,w),R}finally{m._sqlite3_free(q)}}}(),p.progress_handler=function(d,f,u,v){fe(d),m.progress_handler(d,f,u,v)},p.reset=function(){let d="sqlite3_reset",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){F(u);let v=await f(u);return B(d,v,G.get(u))}}(),p.result=function(d,f){switch(typeof f){case"number":f===(f|0)?p.result_int(d,f):p.result_double(d,f);break;case"string":p.result_text(d,f);break;default:if(f instanceof Uint8Array||Array.isArray(f))p.result_blob(d,f);else if(f===null)p.result_null(d);else{if(typeof f=="bigint")return p.result_int64(d,f);console.warn("unknown result converted to null",f),p.result_null(d)}break}},p.result_blob=function(){let f=m.cwrap("sqlite3_result_blob",...I("nnnn:n"));return function(u,v){let q=v.byteLength??v.length,w=m._sqlite3_malloc(q);m.HEAPU8.subarray(w).set(v),f(u,w,q,K)}}(),p.result_double=function(){let f=m.cwrap("sqlite3_result_double",...I("nn:n"));return function(u,v){f(u,v)}}(),p.result_int=function(){let f=m.cwrap("sqlite3_result_int",...I("nn:n"));return function(u,v){f(u,v)}}(),p.result_int64=function(){let f=m.cwrap("sqlite3_result_int64",...I("nnn:n"));return function(u,v){if(v>gt||v>32n;f(u,Number(q),Number(w))}}(),p.result_null=function(){let f=m.cwrap("sqlite3_result_null",...I("n:n"));return function(u){f(u)}}(),p.result_text=function(){let f=m.cwrap("sqlite3_result_text",...I("nnnn:n"));return function(u,v){let q=re(v);f(u,q,-1,K)}}(),p.row=function(d){let f=[],u=p.data_count(d);for(let v=0;vR(v(D,W,j,k,C,U)):(D,W,j,k,C,U)=>R(v(D,W,j,k,C,U))}let w=m.set_authorizer(d,q(f),u);return B("sqlite3_set_authorizer",w,d)},p.sql=function(){let f=m.cwrap("sqlite3_sql",...I("n:s"));return function(u){return F(u),f(u)}}(),p.statements=function(d,f,u={}){let v=m.cwrap("sqlite3_prepare_v3","number",["number","number","number","number","number","number"],{async:!0});return async function*(){let q=[];try{let U=function(){C&&!u.unscoped&&p.finalize(C),C=0},w=new TextEncoder().encode(f),R=w.byteLength-w.byteLength%4+12,D=m._sqlite3_malloc(R),W=D+w.byteLength+1;q.push(()=>m._sqlite3_free(D)),m.HEAPU8.set(w,D),m.HEAPU8[W-1]=0;let j=D+R-8,k=D+R-4,C;q.push(U),m.setValue(k,D,"*");do{U();let Z=m.getValue(k,"*"),y=await ae(()=>v(d,Z,W-k,u.flags||0,j,k));y!==0&&B("sqlite3_prepare_v3",y,d),C=m.getValue(j,"*"),C&&(G.set(C,d),yield C)}while(C)}finally{for(;q.length;)q.pop()()}}()},p.step=function(){let d="sqlite3_step",f=m.cwrap(d,...I("n:n"),{async:Se});return async function(u){F(u);let v=await ae(()=>f(u));return B(d,v,G.get(u),[100,101])}}(),p.value=function(d){let f=p.value_type(d);switch(f){case 4:return p.value_blob(d);case 2:return p.value_double(d);case 1:let u=p.value_int(d),v=m.getTempRet0();return ge(u,v);case 5:return null;case 3:return p.value_text(d);default:throw new ue("unknown type",f)}},p.value_blob=function(){let f=m.cwrap("sqlite3_value_blob",...I("n:n"));return function(u){let v=p.value_bytes(u),q=f(u);return m.HEAPU8.subarray(q,q+v)}}(),p.value_bytes=function(){let f=m.cwrap("sqlite3_value_bytes",...I("n:n"));return function(u){return f(u)}}(),p.value_double=function(){let f=m.cwrap("sqlite3_value_double",...I("n:n"));return function(u){return f(u)}}(),p.value_int=function(){let f=m.cwrap("sqlite3_value_int64",...I("n:n"));return function(u){return f(u)}}(),p.value_int64=function(){let f=m.cwrap("sqlite3_value_int64",...I("n:n"));return function(u){let v=f(u),q=m.getTempRet0();return he(v,q)}}(),p.value_text=function(){let f=m.cwrap("sqlite3_value_text",...I("n:s"));return function(u){return f(u)}}(),p.value_type=function(){let f=m.cwrap("sqlite3_value_type",...I("n:n"));return function(u){return f(u)}}(),p.vfs_register=function(d,f){let u=m.vfs_register(d,f);return B("sqlite3_vfs_register",u)};function B(d,f,u=null,v=[0]){if(v.includes(f))return f;let q=u?m.ccall("sqlite3_errmsg","string",["number"],[u]):d;throw new ue(q,f)}async function ae(d){let f;do m.retryOps.length&&(await Promise.all(m.retryOps),m.retryOps=[]),f=await d();while(f&&m.retryOps.length);return f}return p}function I(m){let p=[],K=m.match(/([ns@]*):([nsv@])/);switch(K[2]){case"n":p.push("number");break;case"s":p.push("string");break;case"v":p.push(null);break}let n=[];for(let ie of K[1])switch(ie){case"n":n.push("number");break;case"s":n.push("string");break}return p.push(n),p}var ja=(()=>{var m=import.meta.url;return function(p={}){var K,n=p,ie,re,he=new Promise((e,t)=>{ie=e,re=t}),ge=typeof window=="object",ne=typeof importScripts=="function",fe=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string",G=Object.assign({},n),F=[],B="./this.program",ae=(e,t)=>{throw t},d="";function f(e){return n.locateFile?n.locateFile(e,d):d+e}var u,v;(ge||ne)&&(ne?d=self.location.href:typeof document<"u"&&document.currentScript&&(d=document.currentScript.src),m&&(d=m),d.startsWith("blob:")?d="":d=d.substr(0,d.replace(/[?#].*/,"").lastIndexOf("/")+1),ne&&(v=e=>{var t=new XMLHttpRequest;return t.open("GET",e,!1),t.responseType="arraybuffer",t.send(null),new Uint8Array(t.response)}),u=e=>fetch(e,{credentials:"same-origin"}).then(t=>t.ok?t.arrayBuffer():Promise.reject(new Error(t.status+" : "+t.url))));var q=n.print||console.log.bind(console),w=n.printErr||console.error.bind(console);Object.assign(n,G),G=null,n.arguments&&(F=n.arguments),n.thisProgram&&(B=n.thisProgram),n.quit&&(ae=n.quit);var R;n.wasmBinary&&(R=n.wasmBinary);var D,W=!1,j,k,C,U,Z,y,z,Oe,Qe;function He(){var e=D.buffer;n.HEAP8=k=new Int8Array(e),n.HEAP16=U=new Int16Array(e),n.HEAPU8=C=new Uint8Array(e),n.HEAPU16=Z=new Uint16Array(e),n.HEAP32=y=new Int32Array(e),n.HEAPU32=z=new Uint32Array(e),n.HEAPF32=Oe=new Float32Array(e),n.HEAPF64=Qe=new Float64Array(e)}var We=[],je=[],Rt=[],Ge=[],kt=!1;function Ot(){if(n.preRun)for(typeof n.preRun=="function"&&(n.preRun=[n.preRun]);n.preRun.length;)Pt(n.preRun.shift());xe(We)}function Qt(){kt=!0,!n.noFSInit&&!s.init.initialized&&s.init(),s.ignorePermissions=!1,se.init(),xe(je)}function Ct(){xe(Rt)}function Ft(){if(n.postRun)for(typeof n.postRun=="function"&&(n.postRun=[n.postRun]);n.postRun.length;)Mt(n.postRun.shift());xe(Ge)}function Pt(e){We.unshift(e)}function Dt(e){je.unshift(e)}function Mt(e){Ge.unshift(e)}var le=0,Ce=null,be=null;function Ka(e){return e}function Fe(e){le++,n.monitorRunDependencies?.(le)}function Ie(e){if(le--,n.monitorRunDependencies?.(le),le==0&&(Ce!==null&&(clearInterval(Ce),Ce=null),be)){var t=be;be=null,t()}}function _e(e){n.onAbort?.(e),e="Aborted("+e+")",w(e),W=!0,j=1,e+=". Build with -sASSERTIONS for more info.";var t=new WebAssembly.RuntimeError(e);throw re(t),t}var Ut="data:application/octet-stream;base64,",Ke=e=>e.startsWith(Ut);function zt(){if(n.locateFile){var e="wa-sqlite.wasm";return Ke(e)?e:f(e)}return new URL("wa-sqlite.wasm",import.meta.url).href}var Le;function Ve(e){if(e==Le&&R)return new Uint8Array(R);if(v)return v(e);throw"both async and sync fetching of the wasm failed"}function Bt(e){return R?Promise.resolve().then(()=>Ve(e)):u(e).then(t=>new Uint8Array(t),()=>Ve(e))}function Xe(e,t,r){return Bt(e).then(_=>WebAssembly.instantiate(_,t)).then(r,_=>{w(`failed to asynchronously prepare wasm: ${_}`),_e(_)})}function Ht(e,t,r,_){return!e&&typeof WebAssembly.instantiateStreaming=="function"&&!Ke(t)&&typeof fetch=="function"?fetch(t,{credentials:"same-origin"}).then(o=>{var a=WebAssembly.instantiateStreaming(o,r);return a.then(_,function(l){return w(`wasm streaming compile failed: ${l}`),w("falling back to ArrayBuffer instantiation"),Xe(t,r,_)})}):Xe(t,r,_)}function Wt(){return{a:Kn}}function jt(){var e=Wt();function t(_,o){return i=_.exports,D=i.ja,He(),ve=i.af,Dt(i.ka),Ie("wasm-instantiate"),i}Fe("wasm-instantiate");function r(_){t(_.instance)}if(n.instantiateWasm)try{return n.instantiateWasm(e,t)}catch(_){w(`Module.instantiateWasm callback failed with error: ${_}`),re(_)}return Le||(Le=zt()),Ht(R,Le,e,r).catch(re),{}}var S,P;function Ye(e){this.name="ExitStatus",this.message=`Program terminated with exit(${e})`,this.status=e}var xe=e=>{for(;e.length>0;)e.shift()(n)};function $e(e,t="i8"){switch(t.endsWith("*")&&(t="*"),t){case"i1":return k[e];case"i8":return k[e];case"i16":return U[e>>1];case"i32":return y[e>>2];case"i64":_e("to do getValue(i64) use WASM_BIGINT");case"float":return Oe[e>>2];case"double":return Qe[e>>3];case"*":return z[e>>2];default:_e(`invalid type for getValue: ${t}`)}}var Gt=n.noExitRuntime||!0;function Ae(e,t,r="i8"){switch(r.endsWith("*")&&(r="*"),r){case"i1":k[e]=t;break;case"i8":k[e]=t;break;case"i16":U[e>>1]=t;break;case"i32":y[e>>2]=t;break;case"i64":_e("to do setValue(i64) use WASM_BIGINT");case"float":Oe[e>>2]=t;break;case"double":Qe[e>>3]=t;break;case"*":z[e>>2]=t;break;default:_e(`invalid type for setValue: ${r}`)}}var Kt=e=>dt(e),Vt=()=>vt(),Ze=typeof TextDecoder<"u"?new TextDecoder:void 0,de=(e,t,r)=>{for(var _=t+r,o=t;e[o]&&!(o>=_);)++o;if(o-t>16&&e.buffer&&Ze)return Ze.decode(e.subarray(t,o));for(var a="";t>10,56320|h&1023)}}return a},ce=(e,t)=>e?de(C,e,t):"",Xt=(e,t,r,_)=>{_e(`Assertion failed: ${ce(e)}, at: `+[t?ce(t):"unknown filename",r,_?ce(_):"unknown function"])},Q={isAbs:e=>e.charAt(0)==="/",splitPath:e=>{var t=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return t.exec(e).slice(1)},normalizeArray:(e,t)=>{for(var r=0,_=e.length-1;_>=0;_--){var o=e[_];o==="."?e.splice(_,1):o===".."?(e.splice(_,1),r++):r&&(e.splice(_,1),r--)}if(t)for(;r;r--)e.unshift("..");return e},normalize:e=>{var t=Q.isAbs(e),r=e.substr(-1)==="/";return e=Q.normalizeArray(e.split("/").filter(_=>!!_),!t).join("/"),!e&&!t&&(e="."),e&&r&&(e+="/"),(t?"/":"")+e},dirname:e=>{var t=Q.splitPath(e),r=t[0],_=t[1];return!r&&!_?".":(_&&(_=_.substr(0,_.length-1)),r+_)},basename:e=>{if(e==="/")return"/";e=Q.normalize(e),e=e.replace(/\/$/,"");var t=e.lastIndexOf("/");return t===-1?e:e.substr(t+1)},join:(...e)=>Q.normalize(e.join("/")),join2:(e,t)=>Q.normalize(e+"/"+t)},Yt=()=>{if(typeof crypto=="object"&&typeof crypto.getRandomValues=="function")return e=>crypto.getRandomValues(e);_e("initRandomDevice")},Je=e=>(Je=Yt())(e),ee={resolve:(...e)=>{for(var t="",r=!1,_=e.length-1;_>=-1&&!r;_--){var o=_>=0?e[_]:s.cwd();if(typeof o!="string")throw new TypeError("Arguments to path.resolve must be strings");if(!o)return"";t=o+"/"+t,r=Q.isAbs(o)}return t=Q.normalizeArray(t.split("/").filter(a=>!!a),!r).join("/"),(r?"/":"")+t||"."},relative:(e,t)=>{e=ee.resolve(e).substr(1),t=ee.resolve(t).substr(1);function r(h){for(var g=0;g=0&&h[A]==="";A--);return g>A?[]:h.slice(g,A-g+1)}for(var _=r(e.split("/")),o=r(t.split("/")),a=Math.min(_.length,o.length),l=a,c=0;c{for(var t=0,r=0;r=55296&&_<=57343?(t+=4,++r):t+=3}return t},De=(e,t,r,_)=>{if(!(_>0))return 0;for(var o=r,a=r+_-1,l=0;l=55296&&c<=57343){var E=e.charCodeAt(++l);c=65536+((c&1023)<<10)|E&1023}if(c<=127){if(r>=a)break;t[r++]=c}else if(c<=2047){if(r+1>=a)break;t[r++]=192|c>>6,t[r++]=128|c&63}else if(c<=65535){if(r+2>=a)break;t[r++]=224|c>>12,t[r++]=128|c>>6&63,t[r++]=128|c&63}else{if(r+3>=a)break;t[r++]=240|c>>18,t[r++]=128|c>>12&63,t[r++]=128|c>>6&63,t[r++]=128|c&63}}return t[r]=0,r-o};function Me(e,t,r){var _=r>0?r:pe(e)+1,o=new Array(_),a=De(e,o,0,o.length);return t&&(o.length=a),o}var $t=()=>{if(!Pe.length){var e=null;if(typeof window<"u"&&typeof window.prompt=="function"&&(e=window.prompt("Input: "),e!==null&&(e+=` -`)),!e)return null;Pe=Me(e,!0)}return Pe.shift()},se={ttys:[],init(){},shutdown(){},register(e,t){se.ttys[e]={input:[],output:[],ops:t},s.registerDevice(e,se.stream_ops)},stream_ops:{open(e){var t=se.ttys[e.node.rdev];if(!t)throw new s.ErrnoError(43);e.tty=t,e.seekable=!1},close(e){e.tty.ops.fsync(e.tty)},fsync(e){e.tty.ops.fsync(e.tty)},read(e,t,r,_,o){if(!e.tty||!e.tty.ops.get_char)throw new s.ErrnoError(60);for(var a=0,l=0;l<_;l++){var c;try{c=e.tty.ops.get_char(e.tty)}catch{throw new s.ErrnoError(29)}if(c===void 0&&a===0)throw new s.ErrnoError(6);if(c==null)break;a++,t[r+l]=c}return a&&(e.node.timestamp=Date.now()),a},write(e,t,r,_,o){if(!e.tty||!e.tty.ops.put_char)throw new s.ErrnoError(60);try{for(var a=0;a<_;a++)e.tty.ops.put_char(e.tty,t[r+a])}catch{throw new s.ErrnoError(29)}return _&&(e.node.timestamp=Date.now()),a}},default_tty_ops:{get_char(e){return $t()},put_char(e,t){t===null||t===10?(q(de(e.output,0)),e.output=[]):t!=0&&e.output.push(t)},fsync(e){e.output&&e.output.length>0&&(q(de(e.output,0)),e.output=[])},ioctl_tcgets(e){return{c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(e,t,r){return 0},ioctl_tiocgwinsz(e){return[24,80]}},default_tty1_ops:{put_char(e,t){t===null||t===10?(w(de(e.output,0)),e.output=[]):t!=0&&e.output.push(t)},fsync(e){e.output&&e.output.length>0&&(w(de(e.output,0)),e.output=[])}}},Zt=(e,t)=>(C.fill(0,e,e+t),e),Jt=(e,t)=>Math.ceil(e/t)*t,et=e=>{e=Jt(e,65536);var t=ut(65536,e);return t?Zt(t,e):0},L={ops_table:null,mount(e){return L.createNode(null,"/",16895,0)},createNode(e,t,r,_){if(s.isBlkdev(r)||s.isFIFO(r))throw new s.ErrnoError(63);L.ops_table||={dir:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr,lookup:L.node_ops.lookup,mknod:L.node_ops.mknod,rename:L.node_ops.rename,unlink:L.node_ops.unlink,rmdir:L.node_ops.rmdir,readdir:L.node_ops.readdir,symlink:L.node_ops.symlink},stream:{llseek:L.stream_ops.llseek}},file:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr},stream:{llseek:L.stream_ops.llseek,read:L.stream_ops.read,write:L.stream_ops.write,allocate:L.stream_ops.allocate,mmap:L.stream_ops.mmap,msync:L.stream_ops.msync}},link:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr,readlink:L.node_ops.readlink},stream:{}},chrdev:{node:{getattr:L.node_ops.getattr,setattr:L.node_ops.setattr},stream:s.chrdev_stream_ops}};var o=s.createNode(e,t,r,_);return s.isDir(o.mode)?(o.node_ops=L.ops_table.dir.node,o.stream_ops=L.ops_table.dir.stream,o.contents={}):s.isFile(o.mode)?(o.node_ops=L.ops_table.file.node,o.stream_ops=L.ops_table.file.stream,o.usedBytes=0,o.contents=null):s.isLink(o.mode)?(o.node_ops=L.ops_table.link.node,o.stream_ops=L.ops_table.link.stream):s.isChrdev(o.mode)&&(o.node_ops=L.ops_table.chrdev.node,o.stream_ops=L.ops_table.chrdev.stream),o.timestamp=Date.now(),e&&(e.contents[t]=o,e.timestamp=o.timestamp),o},getFileDataAsTypedArray(e){return e.contents?e.contents.subarray?e.contents.subarray(0,e.usedBytes):new Uint8Array(e.contents):new Uint8Array(0)},expandFileStorage(e,t){var r=e.contents?e.contents.length:0;if(!(r>=t)){var _=1024*1024;t=Math.max(t,r*(r<_?2:1.125)>>>0),r!=0&&(t=Math.max(t,256));var o=e.contents;e.contents=new Uint8Array(t),e.usedBytes>0&&e.contents.set(o.subarray(0,e.usedBytes),0)}},resizeFileStorage(e,t){if(e.usedBytes!=t)if(t==0)e.contents=null,e.usedBytes=0;else{var r=e.contents;e.contents=new Uint8Array(t),r&&e.contents.set(r.subarray(0,Math.min(t,e.usedBytes))),e.usedBytes=t}},node_ops:{getattr(e){var t={};return t.dev=s.isChrdev(e.mode)?e.id:1,t.ino=e.id,t.mode=e.mode,t.nlink=1,t.uid=0,t.gid=0,t.rdev=e.rdev,s.isDir(e.mode)?t.size=4096:s.isFile(e.mode)?t.size=e.usedBytes:s.isLink(e.mode)?t.size=e.link.length:t.size=0,t.atime=new Date(e.timestamp),t.mtime=new Date(e.timestamp),t.ctime=new Date(e.timestamp),t.blksize=4096,t.blocks=Math.ceil(t.size/t.blksize),t},setattr(e,t){t.mode!==void 0&&(e.mode=t.mode),t.timestamp!==void 0&&(e.timestamp=t.timestamp),t.size!==void 0&&L.resizeFileStorage(e,t.size)},lookup(e,t){throw s.genericErrors[44]},mknod(e,t,r,_){return L.createNode(e,t,r,_)},rename(e,t,r){if(s.isDir(e.mode)){var _;try{_=s.lookupNode(t,r)}catch{}if(_)for(var o in _.contents)throw new s.ErrnoError(55)}delete e.parent.contents[e.name],e.parent.timestamp=Date.now(),e.name=r,t.contents[r]=e,t.timestamp=e.parent.timestamp},unlink(e,t){delete e.contents[t],e.timestamp=Date.now()},rmdir(e,t){var r=s.lookupNode(e,t);for(var _ in r.contents)throw new s.ErrnoError(55);delete e.contents[t],e.timestamp=Date.now()},readdir(e){var t=[".",".."];for(var r of Object.keys(e.contents))t.push(r);return t},symlink(e,t,r){var _=L.createNode(e,t,41471,0);return _.link=r,_},readlink(e){if(!s.isLink(e.mode))throw new s.ErrnoError(28);return e.link}},stream_ops:{read(e,t,r,_,o){var a=e.node.contents;if(o>=e.node.usedBytes)return 0;var l=Math.min(e.node.usedBytes-o,_);if(l>8&&a.subarray)t.set(a.subarray(o,o+l),r);else for(var c=0;c0||r+t{var o=_?"":`al ${e}`;u(e).then(a=>{t(new Uint8Array(a)),o&&Ie(o)},a=>{if(r)r();else throw`Loading data file "${e}" failed.`}),o&&Fe(o)},tr=(e,t,r,_,o,a)=>{s.createDataFile(e,t,r,_,o,a)},rr=n.preloadPlugins||[],nr=(e,t,r,_)=>{typeof Browser<"u"&&Browser.init();var o=!1;return rr.forEach(a=>{o||a.canHandle(t)&&(a.handle(e,t,r,_),o=!0)}),o},_r=(e,t,r,_,o,a,l,c,E,h)=>{var g=t?ee.resolve(Q.join2(e,t)):e,A=`cp ${g}`;function x(T){function b(M){h?.(),c||tr(e,t,M,_,o,E),a?.(),Ie(A)}nr(T,g,b,()=>{l?.(),Ie(A)})||b(T)}Fe(A),typeof r=="string"?er(r,x,l):x(r)},sr=e=>{var t={r:0,"r+":2,w:577,"w+":578,a:1089,"a+":1090},r=t[e];if(typeof r>"u")throw new Error(`Unknown file open mode: ${e}`);return r},Ue=(e,t)=>{var r=0;return e&&(r|=365),t&&(r|=146),r},s={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:!1,ignorePermissions:!0,ErrnoError:class{constructor(e){this.name="ErrnoError",this.errno=e}},genericErrors:{},filesystems:null,syncFSRequests:0,FSStream:class{constructor(){this.shared={}}get object(){return this.node}set object(e){this.node=e}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(e){this.shared.flags=e}get position(){return this.shared.position}set position(e){this.shared.position=e}},FSNode:class{constructor(e,t,r,_){e||(e=this),this.parent=e,this.mount=e.mount,this.mounted=null,this.id=s.nextInode++,this.name=t,this.mode=r,this.node_ops={},this.stream_ops={},this.rdev=_,this.readMode=365,this.writeMode=146}get read(){return(this.mode&this.readMode)===this.readMode}set read(e){e?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(e){e?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return s.isDir(this.mode)}get isDevice(){return s.isChrdev(this.mode)}},lookupPath(e,t={}){if(e=ee.resolve(e),!e)return{path:"",node:null};var r={follow_mount:!0,recurse_count:0};if(t=Object.assign(r,t),t.recurse_count>8)throw new s.ErrnoError(32);for(var _=e.split("/").filter(A=>!!A),o=s.root,a="/",l=0;l<_.length;l++){var c=l===_.length-1;if(c&&t.parent)break;if(o=s.lookupNode(o,_[l]),a=Q.join2(a,_[l]),s.isMountpoint(o)&&(!c||c&&t.follow_mount)&&(o=o.mounted.root),!c||t.follow)for(var E=0;s.isLink(o.mode);){var h=s.readlink(a);a=ee.resolve(Q.dirname(a),h);var g=s.lookupPath(a,{recurse_count:t.recurse_count+1});if(o=g.node,E++>40)throw new s.ErrnoError(32)}}return{path:a,node:o}},getPath(e){for(var t;;){if(s.isRoot(e)){var r=e.mount.mountpoint;return t?r[r.length-1]!=="/"?`${r}/${t}`:r+t:r}t=t?`${e.name}/${t}`:e.name,e=e.parent}},hashName(e,t){for(var r=0,_=0;_>>0)%s.nameTable.length},hashAddNode(e){var t=s.hashName(e.parent.id,e.name);e.name_next=s.nameTable[t],s.nameTable[t]=e},hashRemoveNode(e){var t=s.hashName(e.parent.id,e.name);if(s.nameTable[t]===e)s.nameTable[t]=e.name_next;else for(var r=s.nameTable[t];r;){if(r.name_next===e){r.name_next=e.name_next;break}r=r.name_next}},lookupNode(e,t){var r=s.mayLookup(e);if(r)throw new s.ErrnoError(r);for(var _=s.hashName(e.id,t),o=s.nameTable[_];o;o=o.name_next){var a=o.name;if(o.parent.id===e.id&&a===t)return o}return s.lookup(e,t)},createNode(e,t,r,_){var o=new s.FSNode(e,t,r,_);return s.hashAddNode(o),o},destroyNode(e){s.hashRemoveNode(e)},isRoot(e){return e===e.parent},isMountpoint(e){return!!e.mounted},isFile(e){return(e&61440)===32768},isDir(e){return(e&61440)===16384},isLink(e){return(e&61440)===40960},isChrdev(e){return(e&61440)===8192},isBlkdev(e){return(e&61440)===24576},isFIFO(e){return(e&61440)===4096},isSocket(e){return(e&49152)===49152},flagsToPermissionString(e){var t=["r","w","rw"][e&3];return e&512&&(t+="w"),t},nodePermissions(e,t){return s.ignorePermissions?0:t.includes("r")&&!(e.mode&292)||t.includes("w")&&!(e.mode&146)||t.includes("x")&&!(e.mode&73)?2:0},mayLookup(e){if(!s.isDir(e.mode))return 54;var t=s.nodePermissions(e,"x");return t||(e.node_ops.lookup?0:2)},mayCreate(e,t){try{var r=s.lookupNode(e,t);return 20}catch{}return s.nodePermissions(e,"wx")},mayDelete(e,t,r){var _;try{_=s.lookupNode(e,t)}catch(a){return a.errno}var o=s.nodePermissions(e,"wx");if(o)return o;if(r){if(!s.isDir(_.mode))return 54;if(s.isRoot(_)||s.getPath(_)===s.cwd())return 10}else if(s.isDir(_.mode))return 31;return 0},mayOpen(e,t){return e?s.isLink(e.mode)?32:s.isDir(e.mode)&&(s.flagsToPermissionString(t)!=="r"||t&512)?31:s.nodePermissions(e,s.flagsToPermissionString(t)):44},MAX_OPEN_FDS:4096,nextfd(){for(var e=0;e<=s.MAX_OPEN_FDS;e++)if(!s.streams[e])return e;throw new s.ErrnoError(33)},getStreamChecked(e){var t=s.getStream(e);if(!t)throw new s.ErrnoError(8);return t},getStream:e=>s.streams[e],createStream(e,t=-1){return e=Object.assign(new s.FSStream,e),t==-1&&(t=s.nextfd()),e.fd=t,s.streams[t]=e,e},closeStream(e){s.streams[e]=null},dupStream(e,t=-1){var r=s.createStream(e,t);return r.stream_ops?.dup?.(r),r},chrdev_stream_ops:{open(e){var t=s.getDevice(e.node.rdev);e.stream_ops=t.stream_ops,e.stream_ops.open?.(e)},llseek(){throw new s.ErrnoError(70)}},major:e=>e>>8,minor:e=>e&255,makedev:(e,t)=>e<<8|t,registerDevice(e,t){s.devices[e]={stream_ops:t}},getDevice:e=>s.devices[e],getMounts(e){for(var t=[],r=[e];r.length;){var _=r.pop();t.push(_),r.push(..._.mounts)}return t},syncfs(e,t){typeof e=="function"&&(t=e,e=!1),s.syncFSRequests++,s.syncFSRequests>1&&w(`warning: ${s.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);var r=s.getMounts(s.root.mount),_=0;function o(l){return s.syncFSRequests--,t(l)}function a(l){if(l)return a.errored?void 0:(a.errored=!0,o(l));++_>=r.length&&o(null)}r.forEach(l=>{if(!l.type.syncfs)return a(null);l.type.syncfs(l,e,a)})},mount(e,t,r){var _=r==="/",o=!r,a;if(_&&s.root)throw new s.ErrnoError(10);if(!_&&!o){var l=s.lookupPath(r,{follow_mount:!1});if(r=l.path,a=l.node,s.isMountpoint(a))throw new s.ErrnoError(10);if(!s.isDir(a.mode))throw new s.ErrnoError(54)}var c={type:e,opts:t,mountpoint:r,mounts:[]},E=e.mount(c);return E.mount=c,c.root=E,_?s.root=E:a&&(a.mounted=c,a.mount&&a.mount.mounts.push(c)),E},unmount(e){var t=s.lookupPath(e,{follow_mount:!1});if(!s.isMountpoint(t.node))throw new s.ErrnoError(28);var r=t.node,_=r.mounted,o=s.getMounts(_);Object.keys(s.nameTable).forEach(l=>{for(var c=s.nameTable[l];c;){var E=c.name_next;o.includes(c.mount)&&s.destroyNode(c),c=E}}),r.mounted=null;var a=r.mount.mounts.indexOf(_);r.mount.mounts.splice(a,1)},lookup(e,t){return e.node_ops.lookup(e,t)},mknod(e,t,r){var _=s.lookupPath(e,{parent:!0}),o=_.node,a=Q.basename(e);if(!a||a==="."||a==="..")throw new s.ErrnoError(28);var l=s.mayCreate(o,a);if(l)throw new s.ErrnoError(l);if(!o.node_ops.mknod)throw new s.ErrnoError(63);return o.node_ops.mknod(o,a,t,r)},create(e,t){return t=t!==void 0?t:438,t&=4095,t|=32768,s.mknod(e,t,0)},mkdir(e,t){return t=t!==void 0?t:511,t&=1023,t|=16384,s.mknod(e,t,0)},mkdirTree(e,t){for(var r=e.split("/"),_="",o=0;o"u"&&(r=t,t=438),t|=8192,s.mknod(e,t,r)},symlink(e,t){if(!ee.resolve(e))throw new s.ErrnoError(44);var r=s.lookupPath(t,{parent:!0}),_=r.node;if(!_)throw new s.ErrnoError(44);var o=Q.basename(t),a=s.mayCreate(_,o);if(a)throw new s.ErrnoError(a);if(!_.node_ops.symlink)throw new s.ErrnoError(63);return _.node_ops.symlink(_,o,e)},rename(e,t){var r=Q.dirname(e),_=Q.dirname(t),o=Q.basename(e),a=Q.basename(t),l,c,E;if(l=s.lookupPath(e,{parent:!0}),c=l.node,l=s.lookupPath(t,{parent:!0}),E=l.node,!c||!E)throw new s.ErrnoError(44);if(c.mount!==E.mount)throw new s.ErrnoError(75);var h=s.lookupNode(c,o),g=ee.relative(e,_);if(g.charAt(0)!==".")throw new s.ErrnoError(28);if(g=ee.relative(t,r),g.charAt(0)!==".")throw new s.ErrnoError(55);var A;try{A=s.lookupNode(E,a)}catch{}if(h!==A){var x=s.isDir(h.mode),T=s.mayDelete(c,o,x);if(T)throw new s.ErrnoError(T);if(T=A?s.mayDelete(E,a,x):s.mayCreate(E,a),T)throw new s.ErrnoError(T);if(!c.node_ops.rename)throw new s.ErrnoError(63);if(s.isMountpoint(h)||A&&s.isMountpoint(A))throw new s.ErrnoError(10);if(E!==c&&(T=s.nodePermissions(c,"w"),T))throw new s.ErrnoError(T);s.hashRemoveNode(h);try{c.node_ops.rename(h,E,a),h.parent=E}catch(b){throw b}finally{s.hashAddNode(h)}}},rmdir(e){var t=s.lookupPath(e,{parent:!0}),r=t.node,_=Q.basename(e),o=s.lookupNode(r,_),a=s.mayDelete(r,_,!0);if(a)throw new s.ErrnoError(a);if(!r.node_ops.rmdir)throw new s.ErrnoError(63);if(s.isMountpoint(o))throw new s.ErrnoError(10);r.node_ops.rmdir(r,_),s.destroyNode(o)},readdir(e){var t=s.lookupPath(e,{follow:!0}),r=t.node;if(!r.node_ops.readdir)throw new s.ErrnoError(54);return r.node_ops.readdir(r)},unlink(e){var t=s.lookupPath(e,{parent:!0}),r=t.node;if(!r)throw new s.ErrnoError(44);var _=Q.basename(e),o=s.lookupNode(r,_),a=s.mayDelete(r,_,!1);if(a)throw new s.ErrnoError(a);if(!r.node_ops.unlink)throw new s.ErrnoError(63);if(s.isMountpoint(o))throw new s.ErrnoError(10);r.node_ops.unlink(r,_),s.destroyNode(o)},readlink(e){var t=s.lookupPath(e),r=t.node;if(!r)throw new s.ErrnoError(44);if(!r.node_ops.readlink)throw new s.ErrnoError(28);return ee.resolve(s.getPath(r.parent),r.node_ops.readlink(r))},stat(e,t){var r=s.lookupPath(e,{follow:!t}),_=r.node;if(!_)throw new s.ErrnoError(44);if(!_.node_ops.getattr)throw new s.ErrnoError(63);return _.node_ops.getattr(_)},lstat(e){return s.stat(e,!0)},chmod(e,t,r){var _;if(typeof e=="string"){var o=s.lookupPath(e,{follow:!r});_=o.node}else _=e;if(!_.node_ops.setattr)throw new s.ErrnoError(63);_.node_ops.setattr(_,{mode:t&4095|_.mode&-4096,timestamp:Date.now()})},lchmod(e,t){s.chmod(e,t,!0)},fchmod(e,t){var r=s.getStreamChecked(e);s.chmod(r.node,t)},chown(e,t,r,_){var o;if(typeof e=="string"){var a=s.lookupPath(e,{follow:!_});o=a.node}else o=e;if(!o.node_ops.setattr)throw new s.ErrnoError(63);o.node_ops.setattr(o,{timestamp:Date.now()})},lchown(e,t,r){s.chown(e,t,r,!0)},fchown(e,t,r){var _=s.getStreamChecked(e);s.chown(_.node,t,r)},truncate(e,t){if(t<0)throw new s.ErrnoError(28);var r;if(typeof e=="string"){var _=s.lookupPath(e,{follow:!0});r=_.node}else r=e;if(!r.node_ops.setattr)throw new s.ErrnoError(63);if(s.isDir(r.mode))throw new s.ErrnoError(31);if(!s.isFile(r.mode))throw new s.ErrnoError(28);var o=s.nodePermissions(r,"w");if(o)throw new s.ErrnoError(o);r.node_ops.setattr(r,{size:t,timestamp:Date.now()})},ftruncate(e,t){var r=s.getStreamChecked(e);if(!(r.flags&2097155))throw new s.ErrnoError(28);s.truncate(r.node,t)},utime(e,t,r){var _=s.lookupPath(e,{follow:!0}),o=_.node;o.node_ops.setattr(o,{timestamp:Math.max(t,r)})},open(e,t,r){if(e==="")throw new s.ErrnoError(44);t=typeof t=="string"?sr(t):t,t&64?(r=typeof r>"u"?438:r,r=r&4095|32768):r=0;var _;if(typeof e=="object")_=e;else{e=Q.normalize(e);try{var o=s.lookupPath(e,{follow:!(t&131072)});_=o.node}catch{}}var a=!1;if(t&64)if(_){if(t&128)throw new s.ErrnoError(20)}else _=s.mknod(e,r,0),a=!0;if(!_)throw new s.ErrnoError(44);if(s.isChrdev(_.mode)&&(t&=-513),t&65536&&!s.isDir(_.mode))throw new s.ErrnoError(54);if(!a){var l=s.mayOpen(_,t);if(l)throw new s.ErrnoError(l)}t&512&&!a&&s.truncate(_,0),t&=-131713;var c=s.createStream({node:_,path:s.getPath(_),flags:t,seekable:!0,position:0,stream_ops:_.stream_ops,ungotten:[],error:!1});return c.stream_ops.open&&c.stream_ops.open(c),n.logReadFiles&&!(t&1)&&(s.readFiles||(s.readFiles={}),e in s.readFiles||(s.readFiles[e]=1)),c},close(e){if(s.isClosed(e))throw new s.ErrnoError(8);e.getdents&&(e.getdents=null);try{e.stream_ops.close&&e.stream_ops.close(e)}catch(t){throw t}finally{s.closeStream(e.fd)}e.fd=null},isClosed(e){return e.fd===null},llseek(e,t,r){if(s.isClosed(e))throw new s.ErrnoError(8);if(!e.seekable||!e.stream_ops.llseek)throw new s.ErrnoError(70);if(r!=0&&r!=1&&r!=2)throw new s.ErrnoError(28);return e.position=e.stream_ops.llseek(e,t,r),e.ungotten=[],e.position},read(e,t,r,_,o){if(_<0||o<0)throw new s.ErrnoError(28);if(s.isClosed(e))throw new s.ErrnoError(8);if((e.flags&2097155)===1)throw new s.ErrnoError(8);if(s.isDir(e.node.mode))throw new s.ErrnoError(31);if(!e.stream_ops.read)throw new s.ErrnoError(28);var a=typeof o<"u";if(!a)o=e.position;else if(!e.seekable)throw new s.ErrnoError(70);var l=e.stream_ops.read(e,t,r,_,o);return a||(e.position+=l),l},write(e,t,r,_,o,a){if(_<0||o<0)throw new s.ErrnoError(28);if(s.isClosed(e))throw new s.ErrnoError(8);if(!(e.flags&2097155))throw new s.ErrnoError(8);if(s.isDir(e.node.mode))throw new s.ErrnoError(31);if(!e.stream_ops.write)throw new s.ErrnoError(28);e.seekable&&e.flags&1024&&s.llseek(e,0,2);var l=typeof o<"u";if(!l)o=e.position;else if(!e.seekable)throw new s.ErrnoError(70);var c=e.stream_ops.write(e,t,r,_,o,a);return l||(e.position+=c),c},allocate(e,t,r){if(s.isClosed(e))throw new s.ErrnoError(8);if(t<0||r<=0)throw new s.ErrnoError(28);if(!(e.flags&2097155))throw new s.ErrnoError(8);if(!s.isFile(e.node.mode)&&!s.isDir(e.node.mode))throw new s.ErrnoError(43);if(!e.stream_ops.allocate)throw new s.ErrnoError(138);e.stream_ops.allocate(e,t,r)},mmap(e,t,r,_,o){if(_&2&&!(o&2)&&(e.flags&2097155)!==2)throw new s.ErrnoError(2);if((e.flags&2097155)===1)throw new s.ErrnoError(2);if(!e.stream_ops.mmap)throw new s.ErrnoError(43);return e.stream_ops.mmap(e,t,r,_,o)},msync(e,t,r,_,o){return e.stream_ops.msync?e.stream_ops.msync(e,t,r,_,o):0},ioctl(e,t,r){if(!e.stream_ops.ioctl)throw new s.ErrnoError(59);return e.stream_ops.ioctl(e,t,r)},readFile(e,t={}){if(t.flags=t.flags||0,t.encoding=t.encoding||"binary",t.encoding!=="utf8"&&t.encoding!=="binary")throw new Error(`Invalid encoding type "${t.encoding}"`);var r,_=s.open(e,t.flags),o=s.stat(e),a=o.size,l=new Uint8Array(a);return s.read(_,l,0,a,0),t.encoding==="utf8"?r=de(l,0):t.encoding==="binary"&&(r=l),s.close(_),r},writeFile(e,t,r={}){r.flags=r.flags||577;var _=s.open(e,r.flags,r.mode);if(typeof t=="string"){var o=new Uint8Array(pe(t)+1),a=De(t,o,0,o.length);s.write(_,o,0,a,void 0,r.canOwn)}else if(ArrayBuffer.isView(t))s.write(_,t,0,t.byteLength,void 0,r.canOwn);else throw new Error("Unsupported data type");s.close(_)},cwd:()=>s.currentPath,chdir(e){var t=s.lookupPath(e,{follow:!0});if(t.node===null)throw new s.ErrnoError(44);if(!s.isDir(t.node.mode))throw new s.ErrnoError(54);var r=s.nodePermissions(t.node,"x");if(r)throw new s.ErrnoError(r);s.currentPath=t.path},createDefaultDirectories(){s.mkdir("/tmp"),s.mkdir("/home"),s.mkdir("/home/web_user")},createDefaultDevices(){s.mkdir("/dev"),s.registerDevice(s.makedev(1,3),{read:()=>0,write:(_,o,a,l,c)=>l}),s.mkdev("/dev/null",s.makedev(1,3)),se.register(s.makedev(5,0),se.default_tty_ops),se.register(s.makedev(6,0),se.default_tty1_ops),s.mkdev("/dev/tty",s.makedev(5,0)),s.mkdev("/dev/tty1",s.makedev(6,0));var e=new Uint8Array(1024),t=0,r=()=>(t===0&&(t=Je(e).byteLength),e[--t]);s.createDevice("/dev","random",r),s.createDevice("/dev","urandom",r),s.mkdir("/dev/shm"),s.mkdir("/dev/shm/tmp")},createSpecialDirectories(){s.mkdir("/proc");var e=s.mkdir("/proc/self");s.mkdir("/proc/self/fd"),s.mount({mount(){var t=s.createNode(e,"fd",16895,73);return t.node_ops={lookup(r,_){var o=+_,a=s.getStreamChecked(o),l={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>a.path}};return l.parent=l,l}},t}},{},"/proc/self/fd")},createStandardStreams(){n.stdin?s.createDevice("/dev","stdin",n.stdin):s.symlink("/dev/tty","/dev/stdin"),n.stdout?s.createDevice("/dev","stdout",null,n.stdout):s.symlink("/dev/tty","/dev/stdout"),n.stderr?s.createDevice("/dev","stderr",null,n.stderr):s.symlink("/dev/tty1","/dev/stderr");var e=s.open("/dev/stdin",0),t=s.open("/dev/stdout",1),r=s.open("/dev/stderr",1)},staticInit(){[44].forEach(e=>{s.genericErrors[e]=new s.ErrnoError(e),s.genericErrors[e].stack=""}),s.nameTable=new Array(4096),s.mount(L,{},"/"),s.createDefaultDirectories(),s.createDefaultDevices(),s.createSpecialDirectories(),s.filesystems={MEMFS:L}},init(e,t,r){s.init.initialized=!0,n.stdin=e||n.stdin,n.stdout=t||n.stdout,n.stderr=r||n.stderr,s.createStandardStreams()},quit(){s.init.initialized=!1;for(var e=0;ethis.length-1||T<0)){var b=T%this.chunkSize,M=T/this.chunkSize|0;return this.getter(M)[b]}}setDataGetter(T){this.getter=T}cacheLength(){var T=new XMLHttpRequest;if(T.open("HEAD",r,!1),T.send(null),!(T.status>=200&&T.status<300||T.status===304))throw new Error("Couldn't load "+r+". Status: "+T.status);var b=Number(T.getResponseHeader("Content-length")),M,V=(M=T.getResponseHeader("Accept-Ranges"))&&M==="bytes",X=(M=T.getResponseHeader("Content-Encoding"))&&M==="gzip",Y=1024*1024;V||(Y=b);var $=(J,qe)=>{if(J>qe)throw new Error("invalid range ("+J+", "+qe+") or no bytes requested!");if(qe>b-1)throw new Error("only "+b+" bytes available! programmer error!");var H=new XMLHttpRequest;if(H.open("GET",r,!1),b!==Y&&H.setRequestHeader("Range","bytes="+J+"-"+qe),H.responseType="arraybuffer",H.overrideMimeType&&H.overrideMimeType("text/plain; charset=x-user-defined"),H.send(null),!(H.status>=200&&H.status<300||H.status===304))throw new Error("Couldn't load "+r+". Status: "+H.status);return H.response!==void 0?new Uint8Array(H.response||[]):Me(H.responseText||"",!0)},ye=this;ye.setDataGetter(J=>{var qe=J*Y,H=(J+1)*Y-1;if(H=Math.min(H,b-1),typeof ye.chunks[J]>"u"&&(ye.chunks[J]=$(qe,H)),typeof ye.chunks[J]>"u")throw new Error("doXHR failed!");return ye.chunks[J]}),(X||!b)&&(Y=b=1,b=this.getter(0).length,Y=b,q("LazyFiles on gzip forces download of the whole file when length is accessed")),this._length=b,this._chunkSize=Y,this.lengthKnown=!0}get length(){return this.lengthKnown||this.cacheLength(),this._length}get chunkSize(){return this.lengthKnown||this.cacheLength(),this._chunkSize}}if(typeof XMLHttpRequest<"u"){if(!ne)throw"Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";var l=new a,c={isDevice:!1,contents:l}}else var c={isDevice:!1,url:r};var E=s.createFile(e,t,c,_,o);c.contents?E.contents=c.contents:c.url&&(E.contents=null,E.url=c.url),Object.defineProperties(E,{usedBytes:{get:function(){return this.contents.length}}});var h={},g=Object.keys(E.stream_ops);g.forEach(x=>{var T=E.stream_ops[x];h[x]=(...b)=>(s.forceLoadFile(E),T(...b))});function A(x,T,b,M,V){var X=x.node.contents;if(V>=X.length)return 0;var Y=Math.min(X.length-V,M);if(X.slice)for(var $=0;$(s.forceLoadFile(E),A(x,T,b,M,V)),h.mmap=(x,T,b,M,V)=>{s.forceLoadFile(E);var X=et(T);if(!X)throw new s.ErrnoError(48);return A(x,k,X,T,b),{ptr:X,allocated:!0}},E.stream_ops=h,E}},N={DEFAULT_POLLMASK:5,calculateAt(e,t,r){if(Q.isAbs(t))return t;var _;if(e===-100)_=s.cwd();else{var o=N.getStreamFromFD(e);_=o.path}if(t.length==0){if(!r)throw new s.ErrnoError(44);return _}return Q.join2(_,t)},doStat(e,t,r){var _=e(t);y[r>>2]=_.dev,y[r+4>>2]=_.mode,z[r+8>>2]=_.nlink,y[r+12>>2]=_.uid,y[r+16>>2]=_.gid,y[r+20>>2]=_.rdev,P=[_.size>>>0,(S=_.size,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+24>>2]=P[0],y[r+28>>2]=P[1],y[r+32>>2]=4096,y[r+36>>2]=_.blocks;var o=_.atime.getTime(),a=_.mtime.getTime(),l=_.ctime.getTime();return P=[Math.floor(o/1e3)>>>0,(S=Math.floor(o/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+40>>2]=P[0],y[r+44>>2]=P[1],z[r+48>>2]=o%1e3*1e3,P=[Math.floor(a/1e3)>>>0,(S=Math.floor(a/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+56>>2]=P[0],y[r+60>>2]=P[1],z[r+64>>2]=a%1e3*1e3,P=[Math.floor(l/1e3)>>>0,(S=Math.floor(l/1e3),+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+72>>2]=P[0],y[r+76>>2]=P[1],z[r+80>>2]=l%1e3*1e3,P=[_.ino>>>0,(S=_.ino,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[r+88>>2]=P[0],y[r+92>>2]=P[1],0},doMsync(e,t,r,_,o){if(!s.isFile(t.node.mode))throw new s.ErrnoError(43);if(_&2)return 0;var a=C.slice(e,e+r);s.msync(t,a,o,r,_)},getStreamFromFD(e){var t=s.getStreamChecked(e);return t},varargs:void 0,getStr(e){var t=ce(e);return t}};function or(e,t){try{return e=N.getStr(e),s.chmod(e,t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function ir(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t),r&-8)return-28;var o=s.lookupPath(t,{follow:!0}),a=o.node;if(!a)return-44;var l="";return r&4&&(l+="r"),r&2&&(l+="w"),r&1&&(l+="x"),l&&s.nodePermissions(a,l)?-2:0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function ar(e,t){try{return s.fchmod(e,t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function lr(e,t,r){try{return s.fchown(e,t,r),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}function Ne(){var e=y[+N.varargs>>2];return N.varargs+=4,e}var cr=Ne;function ur(e,t,r){N.varargs=r;try{var _=N.getStreamFromFD(e);switch(t){case 0:{var o=Ne();if(o<0)return-28;for(;s.streams[o];)o++;var a;return a=s.dupStream(_,o),a.fd}case 1:case 2:return 0;case 3:return _.flags;case 4:{var o=Ne();return _.flags|=o,0}case 12:{var o=cr(),l=0;return U[o+l>>1]=2,0}case 13:case 14:return 0}return-28}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function fr(e,t){try{var r=N.getStreamFromFD(e);return N.doStat(s.stat,r.path,t)}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}var Te=(e,t)=>t+2097152>>>0<4194305-!!e?(e>>>0)+t*4294967296:NaN;function dr(e,t,r){var _=Te(t,r);try{return isNaN(_)?61:(s.ftruncate(e,_),0)}catch(o){if(typeof s>"u"||o.name!=="ErrnoError")throw o;return-o.errno}}var oe=(e,t,r)=>De(e,C,t,r);function pr(e,t){try{if(t===0)return-28;var r=s.cwd(),_=pe(r)+1;return t<_?-68:(oe(r,e,t),_)}catch(o){if(typeof s>"u"||o.name!=="ErrnoError")throw o;return-o.errno}}function vr(e,t){try{return e=N.getStr(e),N.doStat(s.lstat,e,t)}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function mr(e,t,r){try{return t=N.getStr(t),t=N.calculateAt(e,t),t=Q.normalize(t),t[t.length-1]==="/"&&(t=t.substr(0,t.length-1)),s.mkdir(t,r,0),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}function Er(e,t,r,_){try{t=N.getStr(t);var o=_&256,a=_&4096;return _=_&-6401,t=N.calculateAt(e,t,a),N.doStat(o?s.lstat:s.stat,t,r)}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return-l.errno}}function qr(e,t,r,_){N.varargs=_;try{t=N.getStr(t),t=N.calculateAt(e,t);var o=_?Ne():0;return s.open(t,r,o).fd}catch(a){if(typeof s>"u"||a.name!=="ErrnoError")throw a;return-a.errno}}function hr(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t),_<=0)return-28;var o=s.readlink(t),a=Math.min(_,pe(o)),l=k[r+a];return oe(o,r,_+1),k[r+a]=l,a}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return-c.errno}}function br(e){try{return e=N.getStr(e),s.rmdir(e),0}catch(t){if(typeof s>"u"||t.name!=="ErrnoError")throw t;return-t.errno}}function Tr(e,t){try{return e=N.getStr(e),N.doStat(s.stat,e,t)}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return-r.errno}}function wr(e,t,r){try{return t=N.getStr(t),t=N.calculateAt(e,t),r===0?s.unlink(t):r===512?s.rmdir(t):_e("Invalid flags passed to unlinkat"),0}catch(_){if(typeof s>"u"||_.name!=="ErrnoError")throw _;return-_.errno}}var tt=e=>z[e>>2]+y[e+4>>2]*4294967296;function yr(e,t,r,_){try{if(t=N.getStr(t),t=N.calculateAt(e,t,!0),r){var l=tt(r),c=y[r+8>>2];o=l*1e3+c/1e6,r+=16,l=tt(r),c=y[r+8>>2],a=l*1e3+c/1e6}else var o=Date.now(),a=o;return s.utime(t,o,a),0}catch(E){if(typeof s>"u"||E.name!=="ErrnoError")throw E;return-E.errno}}var Sr=e=>e%4===0&&(e%100!==0||e%400===0),gr=[0,31,60,91,121,152,182,213,244,274,305,335],Ir=[0,31,59,90,120,151,181,212,243,273,304,334],Lr=e=>{var t=Sr(e.getFullYear()),r=t?gr:Ir,_=r[e.getMonth()]+e.getDate()-1;return _};function xr(e,t,r){var _=Te(e,t),o=new Date(_*1e3);y[r>>2]=o.getSeconds(),y[r+4>>2]=o.getMinutes(),y[r+8>>2]=o.getHours(),y[r+12>>2]=o.getDate(),y[r+16>>2]=o.getMonth(),y[r+20>>2]=o.getFullYear()-1900,y[r+24>>2]=o.getDay();var a=Lr(o)|0;y[r+28>>2]=a,y[r+36>>2]=-(o.getTimezoneOffset()*60);var l=new Date(o.getFullYear(),0,1),c=new Date(o.getFullYear(),6,1).getTimezoneOffset(),E=l.getTimezoneOffset(),h=(c!=E&&o.getTimezoneOffset()==Math.min(E,c))|0;y[r+32>>2]=h}function Ar(e,t,r,_,o,a,l,c){var E=Te(o,a);try{if(isNaN(E))return 61;var h=N.getStreamFromFD(_),g=s.mmap(h,e,E,t,r),A=g.ptr;return y[l>>2]=g.allocated,z[c>>2]=A,0}catch(x){if(typeof s>"u"||x.name!=="ErrnoError")throw x;return-x.errno}}function Nr(e,t,r,_,o,a,l){var c=Te(a,l);try{var E=N.getStreamFromFD(o);r&2&&N.doMsync(e,E,t,_,c)}catch(h){if(typeof s>"u"||h.name!=="ErrnoError")throw h;return-h.errno}}var Rr=(e,t,r,_)=>{var o=new Date().getFullYear(),a=new Date(o,0,1),l=new Date(o,6,1),c=a.getTimezoneOffset(),E=l.getTimezoneOffset(),h=Math.max(c,E);z[e>>2]=h*60,y[t>>2]=+(c!=E);var g=T=>T.toLocaleTimeString(void 0,{hour12:!1,timeZoneName:"short"}).split(" ")[1],A=g(a),x=g(l);EDate.now(),rt;rt=()=>performance.now();var Or=()=>2147483648,Qr=e=>{var t=D.buffer,r=(e-t.byteLength+65535)/65536;try{return D.grow(r),He(),1}catch{}},Cr=e=>{var t=C.length;e>>>=0;var r=Or();if(e>r)return!1;for(var _=(E,h)=>E+(h-E%h)%h,o=1;o<=4;o*=2){var a=t*(1+.2/o);a=Math.min(a,e+100663296);var l=Math.min(r,_(Math.max(e,a),65536)),c=Qr(l);if(c)return!0}return!1},ze={},Fr=()=>B||"./this.program",we=()=>{if(!we.strings){var e=(typeof navigator=="object"&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",t={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:e,_:Fr()};for(var r in ze)ze[r]===void 0?delete t[r]:t[r]=ze[r];var _=[];for(var r in t)_.push(`${r}=${t[r]}`);we.strings=_}return we.strings},Pr=(e,t)=>{for(var r=0;r{var r=0;return we().forEach((_,o)=>{var a=t+r;z[e+o*4>>2]=a,Pr(_,a),r+=_.length+1}),0},Mr=(e,t)=>{var r=we();z[e>>2]=r.length;var _=0;return r.forEach(o=>_+=o.length+1),z[t>>2]=_,0};function Ur(e){try{var t=N.getStreamFromFD(e);return s.close(t),0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return r.errno}}function zr(e,t){try{var r=0,_=0,o=0,a=N.getStreamFromFD(e),l=a.tty?2:s.isDir(a.mode)?3:s.isLink(a.mode)?7:4;return k[t]=l,U[t+2>>1]=o,P=[r>>>0,(S=r,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[t+8>>2]=P[0],y[t+12>>2]=P[1],P=[_>>>0,(S=_,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[t+16>>2]=P[0],y[t+20>>2]=P[1],0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return c.errno}}var Br=(e,t,r,_)=>{for(var o=0,a=0;a>2],c=z[t+4>>2];t+=8;var E=s.read(e,k,l,c,_);if(E<0)return-1;if(o+=E,E>2]=a,0}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return l.errno}}function Wr(e,t,r,_,o){var a=Te(t,r);try{if(isNaN(a))return 61;var l=N.getStreamFromFD(e);return s.llseek(l,a,_),P=[l.position>>>0,(S=l.position,+Math.abs(S)>=1?S>0?+Math.floor(S/4294967296)>>>0:~~+Math.ceil((S-+(~~S>>>0))/4294967296)>>>0:0)],y[o>>2]=P[0],y[o+4>>2]=P[1],l.getdents&&a===0&&_===0&&(l.getdents=null),0}catch(c){if(typeof s>"u"||c.name!=="ErrnoError")throw c;return c.errno}}function jr(e){try{var t=N.getStreamFromFD(e);return t.stream_ops?.fsync?t.stream_ops.fsync(t):0}catch(r){if(typeof s>"u"||r.name!=="ErrnoError")throw r;return r.errno}}var Gr=(e,t,r,_)=>{for(var o=0,a=0;a>2],c=z[t+4>>2];t+=8;var E=s.write(e,k,l,c,_);if(E<0)return-1;o+=E,typeof _<"u"&&(_+=E)}return o};function Kr(e,t,r,_){try{var o=N.getStreamFromFD(e),a=Gr(o,t,r);return z[_>>2]=a,0}catch(l){if(typeof s>"u"||l.name!=="ErrnoError")throw l;return l.errno}}var O=function(){let e=typeof Asyncify=="object"?Asyncify.handleAsync.bind(Asyncify):null;n.handleAsync=e;let t=new Map;n.setCallback=(r,_)=>t.set(r,_),n.getCallback=r=>t.get(r),n.deleteCallback=r=>t.delete(r),O=function(r,_,...o){let a=t.get(_),l=null,c=typeof a=="function"?a:a[l=ce(o.shift())];if(r){if(e)return e(()=>c.apply(a,o));throw new Error("Synchronous WebAssembly cannot call async function")}let E=c.apply(a,o);if(typeof E?.then=="function")throw console.error("unexpected Promise",c),new Error(`${l} unexpectedly returned a Promise`);return E}};function Vr(...e){return O(!1,...e)}function Xr(...e){return O(!0,...e)}function Yr(...e){return O(!1,...e)}function $r(...e){return O(!0,...e)}function Zr(...e){return O(!1,...e)}function Jr(...e){return O(!0,...e)}function en(...e){return O(!1,...e)}function tn(...e){return O(!0,...e)}function rn(...e){return O(!1,...e)}function nn(...e){return O(!0,...e)}function _n(...e){return O(!1,...e)}function sn(...e){return O(!0,...e)}function on(...e){return O(!1,...e)}function an(...e){return O(!0,...e)}function ln(...e){return O(!1,...e)}function cn(...e){return O(!0,...e)}function un(...e){return O(!1,...e)}function fn(...e){return O(!0,...e)}function dn(...e){return O(!1,...e)}function pn(...e){return O(!0,...e)}function vn(...e){return O(!1,...e)}function mn(...e){return O(!0,...e)}function En(...e){return O(!1,...e)}function qn(...e){return O(!0,...e)}function hn(...e){return O(!1,...e)}function bn(...e){return O(!0,...e)}function Tn(...e){return O(!1,...e)}function wn(...e){return O(!0,...e)}function yn(...e){return O(!1,...e)}function Sn(...e){return O(!0,...e)}var gn=0,In=()=>Gt||gn>0,Ln=e=>{j=e,In()||(n.onExit?.(e),W=!0),ae(e,new Ye(e))},xn=(e,t)=>{j=e,Ln(e)},An=e=>{if(e instanceof Ye||e=="unwind")return j;ae(1,e)},nt=(e,t)=>{e<128?t.push(e):t.push(e%128|128,e>>7)},Nn=e=>{for(var t={i:"i32",j:"i64",f:"f32",d:"f64",e:"externref",p:"i32"},r={parameters:[],results:e[0]=="v"?[]:[t[e[0]]]},_=1;_{var r=e.slice(0,1),_=e.slice(1),o={i:127,p:127,j:126,f:125,d:124,e:111};t.push(96),nt(_.length,t);for(var a=0;a<_.length;++a)t.push(o[_[a]]);r=="v"?t.push(0):t.push(1,o[r])},kn=(e,t)=>{if(typeof WebAssembly.Function=="function")return new WebAssembly.Function(Nn(t),e);var r=[1];Rn(t,r);var _=[0,97,115,109,1,0,0,0,1];nt(r.length,_),_.push(...r),_.push(2,7,1,1,101,1,102,0,0,7,5,1,1,102,0,0);var o=new WebAssembly.Module(new Uint8Array(_)),a=new WebAssembly.Instance(o,{e:{f:e}}),l=a.exports.f;return l},ve,On=e=>ve.get(e),Qn=(e,t)=>{if(me)for(var r=e;r(me||(me=new WeakMap,Qn(0,ve.length)),me.get(e)||0),_t=[],Fn=()=>{if(_t.length)return _t.pop();try{ve.grow(1)}catch(e){throw e instanceof RangeError?"Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.":e}return ve.length-1},st=(e,t)=>ve.set(e,t),Pn=(e,t)=>{var r=Cn(e);if(r)return r;var _=Fn();try{st(_,e)}catch(a){if(!(a instanceof TypeError))throw a;var o=kn(e,t);st(_,o)}return me.set(e,_),_},ot=e=>{var t=n["_"+e];return t},it=(e,t)=>{k.set(e,t)},at=e=>pt(e),Dn=e=>{var t=pe(e)+1,r=at(t);return oe(e,r,t),r},Ee=(e,t,r,_,o)=>{var a={string:b=>{var M=0;return b!=null&&b!==0&&(M=Dn(b)),M},array:b=>{var M=at(b.length);return it(b,M),M}};function l(b){return t==="string"?ce(b):t==="boolean"?!!b:b}var c=ot(e),E=[],h=0;if(_)for(var g=0;g<_.length;g++){var A=a[r[g]];A?(h===0&&(h=Vt()),E[g]=A(_[g])):E[g]=_[g]}var x=c(...E);function T(b){return h!==0&&Kt(h),l(b)}return x=T(x),x},Mn=(e,t,r,_)=>{var o=!r||r.every(l=>l==="number"||l==="boolean"),a=t!=="string";return a&&o&&!_?ot(e):(...l)=>Ee(e,t,r,l,_)},Un=e=>ft(),zn=(e,t,r)=>{if(r??=2147483647,r<2)return 0;r-=2;for(var _=t,o=r>1]=l,t+=2}return U[t>>1]=0,t-_},Bn=(e,t,r)=>{if(r??=2147483647,r<4)return 0;for(var _=t,o=_+r-4,a=0;a=55296&&l<=57343){var c=e.charCodeAt(++a);l=65536+((l&1023)<<10)|c&1023}if(y[t>>2]=l,t+=4,t+4>o)break}return y[t>>2]=0,t-_},Hn=e=>{for(var t="";;){var r=C[e++];if(!r)return t;t+=String.fromCharCode(r)}},lt=typeof TextDecoder<"u"?new TextDecoder("utf-16le"):void 0,Wn=(e,t)=>{for(var r=e,_=r>>1,o=_+t/2;!(_>=o)&&Z[_];)++_;if(r=_<<1,r-e>32&<)return lt.decode(C.subarray(e,r));for(var a="",l=0;!(l>=t/2);++l){var c=U[e+l*2>>1];if(c==0)break;a+=String.fromCharCode(c)}return a},jn=(e,t)=>{for(var r=0,_="";!(r>=t/4);){var o=y[e+r*4>>2];if(o==0)break;if(++r,o>=65536){var a=o-65536;_+=String.fromCharCode(55296|a>>10,56320|a&1023)}else _+=String.fromCharCode(o)}return _};function Gn(e){for(var t=[],r=0;r255&&(_&=255),t.push(String.fromCharCode(_))}return t.join("")}s.createPreloadedFile=_r,s.staticInit(),O();var Kn={a:Xt,Y:or,$:ir,Z:ar,X:lr,b:ur,W:fr,y:dr,Q:pr,U:vr,N:mr,T:Er,L:qr,J:hr,I:br,V:Tr,G:wr,F:yr,w:xr,u:Ar,v:Nr,M:Rr,n:kr,m:rt,D:Cr,O:Dr,P:Mr,o:Ur,E:zr,K:Hr,x:Wr,S:jr,H:Kr,s:Vr,t:Xr,fa:Yr,ia:$r,i:Zr,j:Jr,c:en,d:tn,ca:rn,da:nn,ea:_n,ga:sn,g:on,h:an,z:ln,A:cn,e:un,f:fn,aa:dn,ba:pn,B:vn,C:mn,p:En,q:qn,ha:hn,r:bn,k:Tn,l:wn,R:yn,_:Sn},i=jt(),Vn=()=>(Vn=i.ka)(),Xn=n._sqlite3_status64=(e,t,r,_)=>(Xn=n._sqlite3_status64=i.la)(e,t,r,_),Yn=n._sqlite3_status=(e,t,r,_)=>(Yn=n._sqlite3_status=i.ma)(e,t,r,_),$n=n._sqlite3_db_status=(e,t,r,_,o)=>($n=n._sqlite3_db_status=i.na)(e,t,r,_,o),Zn=n._sqlite3_msize=e=>(Zn=n._sqlite3_msize=i.oa)(e),Jn=n._sqlite3_vfs_find=e=>(Jn=n._sqlite3_vfs_find=i.pa)(e),e_=n._sqlite3_vfs_register=(e,t)=>(e_=n._sqlite3_vfs_register=i.qa)(e,t),t_=n._sqlite3_vfs_unregister=e=>(t_=n._sqlite3_vfs_unregister=i.ra)(e),r_=n._sqlite3_release_memory=e=>(r_=n._sqlite3_release_memory=i.sa)(e),n_=n._sqlite3_soft_heap_limit64=(e,t)=>(n_=n._sqlite3_soft_heap_limit64=i.ta)(e,t),__=n._sqlite3_memory_used=()=>(__=n._sqlite3_memory_used=i.ua)(),s_=n._sqlite3_hard_heap_limit64=(e,t)=>(s_=n._sqlite3_hard_heap_limit64=i.va)(e,t),o_=n._sqlite3_memory_highwater=e=>(o_=n._sqlite3_memory_highwater=i.wa)(e),i_=n._sqlite3_malloc=e=>(i_=n._sqlite3_malloc=i.xa)(e),a_=n._sqlite3_malloc64=(e,t)=>(a_=n._sqlite3_malloc64=i.ya)(e,t),l_=n._sqlite3_free=e=>(l_=n._sqlite3_free=i.za)(e),c_=n._sqlite3_realloc=(e,t)=>(c_=n._sqlite3_realloc=i.Aa)(e,t),u_=n._sqlite3_realloc64=(e,t,r)=>(u_=n._sqlite3_realloc64=i.Ba)(e,t,r),f_=n._sqlite3_str_vappendf=(e,t,r)=>(f_=n._sqlite3_str_vappendf=i.Ca)(e,t,r),d_=n._sqlite3_str_append=(e,t,r)=>(d_=n._sqlite3_str_append=i.Da)(e,t,r),p_=n._sqlite3_str_appendchar=(e,t,r)=>(p_=n._sqlite3_str_appendchar=i.Ea)(e,t,r),v_=n._sqlite3_str_appendall=(e,t)=>(v_=n._sqlite3_str_appendall=i.Fa)(e,t),m_=n._sqlite3_str_appendf=(e,t,r)=>(m_=n._sqlite3_str_appendf=i.Ga)(e,t,r),E_=n._sqlite3_str_finish=e=>(E_=n._sqlite3_str_finish=i.Ha)(e),q_=n._sqlite3_str_errcode=e=>(q_=n._sqlite3_str_errcode=i.Ia)(e),h_=n._sqlite3_str_length=e=>(h_=n._sqlite3_str_length=i.Ja)(e),b_=n._sqlite3_str_value=e=>(b_=n._sqlite3_str_value=i.Ka)(e),T_=n._sqlite3_str_reset=e=>(T_=n._sqlite3_str_reset=i.La)(e),w_=n._sqlite3_str_new=e=>(w_=n._sqlite3_str_new=i.Ma)(e),y_=n._sqlite3_vmprintf=(e,t)=>(y_=n._sqlite3_vmprintf=i.Na)(e,t),S_=n._sqlite3_mprintf=(e,t)=>(S_=n._sqlite3_mprintf=i.Oa)(e,t),g_=n._sqlite3_vsnprintf=(e,t,r,_)=>(g_=n._sqlite3_vsnprintf=i.Pa)(e,t,r,_),I_=n._sqlite3_snprintf=(e,t,r,_)=>(I_=n._sqlite3_snprintf=i.Qa)(e,t,r,_),L_=n._sqlite3_log=(e,t,r)=>(L_=n._sqlite3_log=i.Ra)(e,t,r),x_=n._sqlite3_randomness=(e,t)=>(x_=n._sqlite3_randomness=i.Sa)(e,t),A_=n._sqlite3_stricmp=(e,t)=>(A_=n._sqlite3_stricmp=i.Ta)(e,t),N_=n._sqlite3_strnicmp=(e,t,r)=>(N_=n._sqlite3_strnicmp=i.Ua)(e,t,r),R_=n._sqlite3_os_init=()=>(R_=n._sqlite3_os_init=i.Va)(),k_=n._sqlite3_os_end=()=>(k_=n._sqlite3_os_end=i.Wa)(),O_=n._sqlite3_serialize=(e,t,r,_)=>(O_=n._sqlite3_serialize=i.Xa)(e,t,r,_),Q_=n._sqlite3_prepare_v2=(e,t,r,_,o)=>(Q_=n._sqlite3_prepare_v2=i.Ya)(e,t,r,_,o),C_=n._sqlite3_step=e=>(C_=n._sqlite3_step=i.Za)(e),F_=n._sqlite3_column_int64=(e,t)=>(F_=n._sqlite3_column_int64=i._a)(e,t),P_=n._sqlite3_reset=e=>(P_=n._sqlite3_reset=i.$a)(e),D_=n._sqlite3_exec=(e,t,r,_,o)=>(D_=n._sqlite3_exec=i.ab)(e,t,r,_,o),M_=n._sqlite3_column_int=(e,t)=>(M_=n._sqlite3_column_int=i.bb)(e,t),U_=n._sqlite3_finalize=e=>(U_=n._sqlite3_finalize=i.cb)(e),z_=n._sqlite3_deserialize=(e,t,r,_,o,a,l,c)=>(z_=n._sqlite3_deserialize=i.db)(e,t,r,_,o,a,l,c),B_=n._sqlite3_database_file_object=e=>(B_=n._sqlite3_database_file_object=i.eb)(e),H_=n._sqlite3_backup_init=(e,t,r,_)=>(H_=n._sqlite3_backup_init=i.fb)(e,t,r,_),W_=n._sqlite3_backup_step=(e,t)=>(W_=n._sqlite3_backup_step=i.gb)(e,t),j_=n._sqlite3_backup_finish=e=>(j_=n._sqlite3_backup_finish=i.hb)(e),G_=n._sqlite3_backup_remaining=e=>(G_=n._sqlite3_backup_remaining=i.ib)(e),K_=n._sqlite3_backup_pagecount=e=>(K_=n._sqlite3_backup_pagecount=i.jb)(e),V_=n._sqlite3_clear_bindings=e=>(V_=n._sqlite3_clear_bindings=i.kb)(e),X_=n._sqlite3_value_blob=e=>(X_=n._sqlite3_value_blob=i.lb)(e),Y_=n._sqlite3_value_text=e=>(Y_=n._sqlite3_value_text=i.mb)(e),$_=n._sqlite3_value_bytes=e=>($_=n._sqlite3_value_bytes=i.nb)(e),Z_=n._sqlite3_value_bytes16=e=>(Z_=n._sqlite3_value_bytes16=i.ob)(e),J_=n._sqlite3_value_double=e=>(J_=n._sqlite3_value_double=i.pb)(e),es=n._sqlite3_value_int=e=>(es=n._sqlite3_value_int=i.qb)(e),ts=n._sqlite3_value_int64=e=>(ts=n._sqlite3_value_int64=i.rb)(e),rs=n._sqlite3_value_subtype=e=>(rs=n._sqlite3_value_subtype=i.sb)(e),ns=n._sqlite3_value_pointer=(e,t)=>(ns=n._sqlite3_value_pointer=i.tb)(e,t),_s=n._sqlite3_value_text16=e=>(_s=n._sqlite3_value_text16=i.ub)(e),ss=n._sqlite3_value_text16be=e=>(ss=n._sqlite3_value_text16be=i.vb)(e),os=n._sqlite3_value_text16le=e=>(os=n._sqlite3_value_text16le=i.wb)(e),is=n._sqlite3_value_type=e=>(is=n._sqlite3_value_type=i.xb)(e),as=n._sqlite3_value_encoding=e=>(as=n._sqlite3_value_encoding=i.yb)(e),ls=n._sqlite3_value_nochange=e=>(ls=n._sqlite3_value_nochange=i.zb)(e),cs=n._sqlite3_value_frombind=e=>(cs=n._sqlite3_value_frombind=i.Ab)(e),us=n._sqlite3_value_dup=e=>(us=n._sqlite3_value_dup=i.Bb)(e),fs=n._sqlite3_value_free=e=>(fs=n._sqlite3_value_free=i.Cb)(e),ds=n._sqlite3_result_blob=(e,t,r,_)=>(ds=n._sqlite3_result_blob=i.Db)(e,t,r,_),ps=n._sqlite3_result_blob64=(e,t,r,_,o)=>(ps=n._sqlite3_result_blob64=i.Eb)(e,t,r,_,o),vs=n._sqlite3_result_double=(e,t)=>(vs=n._sqlite3_result_double=i.Fb)(e,t),ms=n._sqlite3_result_error=(e,t,r)=>(ms=n._sqlite3_result_error=i.Gb)(e,t,r),Es=n._sqlite3_result_error16=(e,t,r)=>(Es=n._sqlite3_result_error16=i.Hb)(e,t,r),qs=n._sqlite3_result_int=(e,t)=>(qs=n._sqlite3_result_int=i.Ib)(e,t),hs=n._sqlite3_result_int64=(e,t,r)=>(hs=n._sqlite3_result_int64=i.Jb)(e,t,r),bs=n._sqlite3_result_null=e=>(bs=n._sqlite3_result_null=i.Kb)(e),Ts=n._sqlite3_result_pointer=(e,t,r,_)=>(Ts=n._sqlite3_result_pointer=i.Lb)(e,t,r,_),ws=n._sqlite3_result_subtype=(e,t)=>(ws=n._sqlite3_result_subtype=i.Mb)(e,t),ys=n._sqlite3_result_text=(e,t,r,_)=>(ys=n._sqlite3_result_text=i.Nb)(e,t,r,_),Ss=n._sqlite3_result_text64=(e,t,r,_,o,a)=>(Ss=n._sqlite3_result_text64=i.Ob)(e,t,r,_,o,a),gs=n._sqlite3_result_text16=(e,t,r,_)=>(gs=n._sqlite3_result_text16=i.Pb)(e,t,r,_),Is=n._sqlite3_result_text16be=(e,t,r,_)=>(Is=n._sqlite3_result_text16be=i.Qb)(e,t,r,_),Ls=n._sqlite3_result_text16le=(e,t,r,_)=>(Ls=n._sqlite3_result_text16le=i.Rb)(e,t,r,_),xs=n._sqlite3_result_value=(e,t)=>(xs=n._sqlite3_result_value=i.Sb)(e,t),As=n._sqlite3_result_error_toobig=e=>(As=n._sqlite3_result_error_toobig=i.Tb)(e),Ns=n._sqlite3_result_zeroblob=(e,t)=>(Ns=n._sqlite3_result_zeroblob=i.Ub)(e,t),Rs=n._sqlite3_result_zeroblob64=(e,t,r)=>(Rs=n._sqlite3_result_zeroblob64=i.Vb)(e,t,r),ks=n._sqlite3_result_error_code=(e,t)=>(ks=n._sqlite3_result_error_code=i.Wb)(e,t),Os=n._sqlite3_result_error_nomem=e=>(Os=n._sqlite3_result_error_nomem=i.Xb)(e),Qs=n._sqlite3_user_data=e=>(Qs=n._sqlite3_user_data=i.Yb)(e),Cs=n._sqlite3_context_db_handle=e=>(Cs=n._sqlite3_context_db_handle=i.Zb)(e),Fs=n._sqlite3_vtab_nochange=e=>(Fs=n._sqlite3_vtab_nochange=i._b)(e),Ps=n._sqlite3_vtab_in_first=(e,t)=>(Ps=n._sqlite3_vtab_in_first=i.$b)(e,t),Ds=n._sqlite3_vtab_in_next=(e,t)=>(Ds=n._sqlite3_vtab_in_next=i.ac)(e,t),Ms=n._sqlite3_aggregate_context=(e,t)=>(Ms=n._sqlite3_aggregate_context=i.bc)(e,t),Us=n._sqlite3_get_auxdata=(e,t)=>(Us=n._sqlite3_get_auxdata=i.cc)(e,t),zs=n._sqlite3_set_auxdata=(e,t,r,_)=>(zs=n._sqlite3_set_auxdata=i.dc)(e,t,r,_),Bs=n._sqlite3_column_count=e=>(Bs=n._sqlite3_column_count=i.ec)(e),Hs=n._sqlite3_data_count=e=>(Hs=n._sqlite3_data_count=i.fc)(e),Ws=n._sqlite3_column_blob=(e,t)=>(Ws=n._sqlite3_column_blob=i.gc)(e,t),js=n._sqlite3_column_bytes=(e,t)=>(js=n._sqlite3_column_bytes=i.hc)(e,t),Gs=n._sqlite3_column_bytes16=(e,t)=>(Gs=n._sqlite3_column_bytes16=i.ic)(e,t),Ks=n._sqlite3_column_double=(e,t)=>(Ks=n._sqlite3_column_double=i.jc)(e,t),Vs=n._sqlite3_column_text=(e,t)=>(Vs=n._sqlite3_column_text=i.kc)(e,t),Xs=n._sqlite3_column_value=(e,t)=>(Xs=n._sqlite3_column_value=i.lc)(e,t),Ys=n._sqlite3_column_text16=(e,t)=>(Ys=n._sqlite3_column_text16=i.mc)(e,t),$s=n._sqlite3_column_type=(e,t)=>($s=n._sqlite3_column_type=i.nc)(e,t),Zs=n._sqlite3_column_name=(e,t)=>(Zs=n._sqlite3_column_name=i.oc)(e,t),Js=n._sqlite3_column_name16=(e,t)=>(Js=n._sqlite3_column_name16=i.pc)(e,t),eo=n._sqlite3_bind_blob=(e,t,r,_,o)=>(eo=n._sqlite3_bind_blob=i.qc)(e,t,r,_,o),to=n._sqlite3_bind_blob64=(e,t,r,_,o,a)=>(to=n._sqlite3_bind_blob64=i.rc)(e,t,r,_,o,a),ro=n._sqlite3_bind_double=(e,t,r)=>(ro=n._sqlite3_bind_double=i.sc)(e,t,r),no=n._sqlite3_bind_int=(e,t,r)=>(no=n._sqlite3_bind_int=i.tc)(e,t,r),_o=n._sqlite3_bind_int64=(e,t,r,_)=>(_o=n._sqlite3_bind_int64=i.uc)(e,t,r,_),so=n._sqlite3_bind_null=(e,t)=>(so=n._sqlite3_bind_null=i.vc)(e,t),oo=n._sqlite3_bind_pointer=(e,t,r,_,o)=>(oo=n._sqlite3_bind_pointer=i.wc)(e,t,r,_,o),io=n._sqlite3_bind_text=(e,t,r,_,o)=>(io=n._sqlite3_bind_text=i.xc)(e,t,r,_,o),ao=n._sqlite3_bind_text64=(e,t,r,_,o,a,l)=>(ao=n._sqlite3_bind_text64=i.yc)(e,t,r,_,o,a,l),lo=n._sqlite3_bind_text16=(e,t,r,_,o)=>(lo=n._sqlite3_bind_text16=i.zc)(e,t,r,_,o),co=n._sqlite3_bind_value=(e,t,r)=>(co=n._sqlite3_bind_value=i.Ac)(e,t,r),uo=n._sqlite3_bind_zeroblob=(e,t,r)=>(uo=n._sqlite3_bind_zeroblob=i.Bc)(e,t,r),fo=n._sqlite3_bind_zeroblob64=(e,t,r,_)=>(fo=n._sqlite3_bind_zeroblob64=i.Cc)(e,t,r,_),po=n._sqlite3_bind_parameter_count=e=>(po=n._sqlite3_bind_parameter_count=i.Dc)(e),vo=n._sqlite3_bind_parameter_name=(e,t)=>(vo=n._sqlite3_bind_parameter_name=i.Ec)(e,t),mo=n._sqlite3_bind_parameter_index=(e,t)=>(mo=n._sqlite3_bind_parameter_index=i.Fc)(e,t),Eo=n._sqlite3_db_handle=e=>(Eo=n._sqlite3_db_handle=i.Gc)(e),qo=n._sqlite3_stmt_readonly=e=>(qo=n._sqlite3_stmt_readonly=i.Hc)(e),ho=n._sqlite3_stmt_isexplain=e=>(ho=n._sqlite3_stmt_isexplain=i.Ic)(e),bo=n._sqlite3_stmt_explain=(e,t)=>(bo=n._sqlite3_stmt_explain=i.Jc)(e,t),To=n._sqlite3_stmt_busy=e=>(To=n._sqlite3_stmt_busy=i.Kc)(e),wo=n._sqlite3_next_stmt=(e,t)=>(wo=n._sqlite3_next_stmt=i.Lc)(e,t),yo=n._sqlite3_stmt_status=(e,t,r)=>(yo=n._sqlite3_stmt_status=i.Mc)(e,t,r),So=n._sqlite3_sql=e=>(So=n._sqlite3_sql=i.Nc)(e),go=n._sqlite3_expanded_sql=e=>(go=n._sqlite3_expanded_sql=i.Oc)(e),Io=n._sqlite3_value_numeric_type=e=>(Io=n._sqlite3_value_numeric_type=i.Pc)(e),Lo=n._sqlite3_blob_open=(e,t,r,_,o,a,l,c)=>(Lo=n._sqlite3_blob_open=i.Qc)(e,t,r,_,o,a,l,c),xo=n._sqlite3_blob_close=e=>(xo=n._sqlite3_blob_close=i.Rc)(e),Ao=n._sqlite3_blob_read=(e,t,r,_)=>(Ao=n._sqlite3_blob_read=i.Sc)(e,t,r,_),No=n._sqlite3_blob_write=(e,t,r,_)=>(No=n._sqlite3_blob_write=i.Tc)(e,t,r,_),Ro=n._sqlite3_blob_bytes=e=>(Ro=n._sqlite3_blob_bytes=i.Uc)(e),ko=n._sqlite3_blob_reopen=(e,t,r)=>(ko=n._sqlite3_blob_reopen=i.Vc)(e,t,r),Oo=n._sqlite3_set_authorizer=(e,t,r)=>(Oo=n._sqlite3_set_authorizer=i.Wc)(e,t,r),Qo=n._sqlite3_strglob=(e,t)=>(Qo=n._sqlite3_strglob=i.Xc)(e,t),Co=n._sqlite3_strlike=(e,t,r)=>(Co=n._sqlite3_strlike=i.Yc)(e,t,r),Fo=n._sqlite3_errmsg=e=>(Fo=n._sqlite3_errmsg=i.Zc)(e),Po=n._sqlite3_auto_extension=e=>(Po=n._sqlite3_auto_extension=i._c)(e),Do=n._sqlite3_cancel_auto_extension=e=>(Do=n._sqlite3_cancel_auto_extension=i.$c)(e),Mo=n._sqlite3_reset_auto_extension=()=>(Mo=n._sqlite3_reset_auto_extension=i.ad)(),Uo=n._sqlite3_prepare=(e,t,r,_,o)=>(Uo=n._sqlite3_prepare=i.bd)(e,t,r,_,o),zo=n._sqlite3_prepare_v3=(e,t,r,_,o,a)=>(zo=n._sqlite3_prepare_v3=i.cd)(e,t,r,_,o,a),Bo=n._sqlite3_prepare16=(e,t,r,_,o)=>(Bo=n._sqlite3_prepare16=i.dd)(e,t,r,_,o),Ho=n._sqlite3_prepare16_v2=(e,t,r,_,o)=>(Ho=n._sqlite3_prepare16_v2=i.ed)(e,t,r,_,o),Wo=n._sqlite3_prepare16_v3=(e,t,r,_,o,a)=>(Wo=n._sqlite3_prepare16_v3=i.fd)(e,t,r,_,o,a),jo=n._sqlite3_get_table=(e,t,r,_,o,a)=>(jo=n._sqlite3_get_table=i.gd)(e,t,r,_,o,a),Go=n._sqlite3_free_table=e=>(Go=n._sqlite3_free_table=i.hd)(e),Ko=n._sqlite3_create_module=(e,t,r,_)=>(Ko=n._sqlite3_create_module=i.id)(e,t,r,_),Vo=n._sqlite3_create_module_v2=(e,t,r,_,o)=>(Vo=n._sqlite3_create_module_v2=i.jd)(e,t,r,_,o),Xo=n._sqlite3_drop_modules=(e,t)=>(Xo=n._sqlite3_drop_modules=i.kd)(e,t),Yo=n._sqlite3_declare_vtab=(e,t)=>(Yo=n._sqlite3_declare_vtab=i.ld)(e,t),$o=n._sqlite3_vtab_on_conflict=e=>($o=n._sqlite3_vtab_on_conflict=i.md)(e),Zo=n._sqlite3_vtab_config=(e,t,r)=>(Zo=n._sqlite3_vtab_config=i.nd)(e,t,r),Jo=n._sqlite3_vtab_collation=(e,t)=>(Jo=n._sqlite3_vtab_collation=i.od)(e,t),ei=n._sqlite3_vtab_in=(e,t,r)=>(ei=n._sqlite3_vtab_in=i.pd)(e,t,r),ti=n._sqlite3_vtab_rhs_value=(e,t,r)=>(ti=n._sqlite3_vtab_rhs_value=i.qd)(e,t,r),ri=n._sqlite3_vtab_distinct=e=>(ri=n._sqlite3_vtab_distinct=i.rd)(e),ni=n._sqlite3_keyword_name=(e,t,r)=>(ni=n._sqlite3_keyword_name=i.sd)(e,t,r),_i=n._sqlite3_keyword_count=()=>(_i=n._sqlite3_keyword_count=i.td)(),si=n._sqlite3_keyword_check=(e,t)=>(si=n._sqlite3_keyword_check=i.ud)(e,t),oi=n._sqlite3_complete=e=>(oi=n._sqlite3_complete=i.vd)(e),ii=n._sqlite3_complete16=e=>(ii=n._sqlite3_complete16=i.wd)(e),ai=n._sqlite3_libversion=()=>(ai=n._sqlite3_libversion=i.xd)(),li=n._sqlite3_libversion_number=()=>(li=n._sqlite3_libversion_number=i.yd)(),ci=n._sqlite3_threadsafe=()=>(ci=n._sqlite3_threadsafe=i.zd)(),ui=n._sqlite3_initialize=()=>(ui=n._sqlite3_initialize=i.Ad)(),fi=n._sqlite3_shutdown=()=>(fi=n._sqlite3_shutdown=i.Bd)(),di=n._sqlite3_config=(e,t)=>(di=n._sqlite3_config=i.Cd)(e,t),pi=n._sqlite3_db_mutex=e=>(pi=n._sqlite3_db_mutex=i.Dd)(e),vi=n._sqlite3_db_release_memory=e=>(vi=n._sqlite3_db_release_memory=i.Ed)(e),mi=n._sqlite3_db_cacheflush=e=>(mi=n._sqlite3_db_cacheflush=i.Fd)(e),Ei=n._sqlite3_db_config=(e,t,r)=>(Ei=n._sqlite3_db_config=i.Gd)(e,t,r),qi=n._sqlite3_last_insert_rowid=e=>(qi=n._sqlite3_last_insert_rowid=i.Hd)(e),hi=n._sqlite3_set_last_insert_rowid=(e,t,r)=>(hi=n._sqlite3_set_last_insert_rowid=i.Id)(e,t,r),bi=n._sqlite3_changes64=e=>(bi=n._sqlite3_changes64=i.Jd)(e),Ti=n._sqlite3_changes=e=>(Ti=n._sqlite3_changes=i.Kd)(e),wi=n._sqlite3_total_changes64=e=>(wi=n._sqlite3_total_changes64=i.Ld)(e),yi=n._sqlite3_total_changes=e=>(yi=n._sqlite3_total_changes=i.Md)(e),Si=n._sqlite3_txn_state=(e,t)=>(Si=n._sqlite3_txn_state=i.Nd)(e,t),gi=n._sqlite3_close=e=>(gi=n._sqlite3_close=i.Od)(e),Ii=n._sqlite3_close_v2=e=>(Ii=n._sqlite3_close_v2=i.Pd)(e),Li=n._sqlite3_busy_handler=(e,t,r)=>(Li=n._sqlite3_busy_handler=i.Qd)(e,t,r),xi=n._sqlite3_progress_handler=(e,t,r,_)=>(xi=n._sqlite3_progress_handler=i.Rd)(e,t,r,_),Ai=n._sqlite3_busy_timeout=(e,t)=>(Ai=n._sqlite3_busy_timeout=i.Sd)(e,t),Ni=n._sqlite3_interrupt=e=>(Ni=n._sqlite3_interrupt=i.Td)(e),Ri=n._sqlite3_is_interrupted=e=>(Ri=n._sqlite3_is_interrupted=i.Ud)(e),ki=n._sqlite3_create_function=(e,t,r,_,o,a,l,c)=>(ki=n._sqlite3_create_function=i.Vd)(e,t,r,_,o,a,l,c),Oi=n._sqlite3_create_function_v2=(e,t,r,_,o,a,l,c,E)=>(Oi=n._sqlite3_create_function_v2=i.Wd)(e,t,r,_,o,a,l,c,E),Qi=n._sqlite3_create_window_function=(e,t,r,_,o,a,l,c,E,h)=>(Qi=n._sqlite3_create_window_function=i.Xd)(e,t,r,_,o,a,l,c,E,h),Ci=n._sqlite3_create_function16=(e,t,r,_,o,a,l,c)=>(Ci=n._sqlite3_create_function16=i.Yd)(e,t,r,_,o,a,l,c),Fi=n._sqlite3_overload_function=(e,t,r)=>(Fi=n._sqlite3_overload_function=i.Zd)(e,t,r),Pi=n._sqlite3_trace_v2=(e,t,r,_)=>(Pi=n._sqlite3_trace_v2=i._d)(e,t,r,_),Di=n._sqlite3_commit_hook=(e,t,r)=>(Di=n._sqlite3_commit_hook=i.$d)(e,t,r),Mi=n._sqlite3_update_hook=(e,t,r)=>(Mi=n._sqlite3_update_hook=i.ae)(e,t,r),Ui=n._sqlite3_rollback_hook=(e,t,r)=>(Ui=n._sqlite3_rollback_hook=i.be)(e,t,r),zi=n._sqlite3_autovacuum_pages=(e,t,r,_)=>(zi=n._sqlite3_autovacuum_pages=i.ce)(e,t,r,_),Bi=n._sqlite3_wal_autocheckpoint=(e,t)=>(Bi=n._sqlite3_wal_autocheckpoint=i.de)(e,t),Hi=n._sqlite3_wal_hook=(e,t,r)=>(Hi=n._sqlite3_wal_hook=i.ee)(e,t,r),Wi=n._sqlite3_wal_checkpoint_v2=(e,t,r,_,o)=>(Wi=n._sqlite3_wal_checkpoint_v2=i.fe)(e,t,r,_,o),ji=n._sqlite3_wal_checkpoint=(e,t)=>(ji=n._sqlite3_wal_checkpoint=i.ge)(e,t),Gi=n._sqlite3_error_offset=e=>(Gi=n._sqlite3_error_offset=i.he)(e),Ki=n._sqlite3_errmsg16=e=>(Ki=n._sqlite3_errmsg16=i.ie)(e),Vi=n._sqlite3_errcode=e=>(Vi=n._sqlite3_errcode=i.je)(e),Xi=n._sqlite3_extended_errcode=e=>(Xi=n._sqlite3_extended_errcode=i.ke)(e),Yi=n._sqlite3_system_errno=e=>(Yi=n._sqlite3_system_errno=i.le)(e),$i=n._sqlite3_errstr=e=>($i=n._sqlite3_errstr=i.me)(e),Zi=n._sqlite3_limit=(e,t,r)=>(Zi=n._sqlite3_limit=i.ne)(e,t,r),Ji=n._sqlite3_open=(e,t)=>(Ji=n._sqlite3_open=i.oe)(e,t),ea=n._sqlite3_open_v2=(e,t,r,_)=>(ea=n._sqlite3_open_v2=i.pe)(e,t,r,_),ta=n._sqlite3_open16=(e,t)=>(ta=n._sqlite3_open16=i.qe)(e,t),ra=n._sqlite3_create_collation=(e,t,r,_,o)=>(ra=n._sqlite3_create_collation=i.re)(e,t,r,_,o),na=n._sqlite3_create_collation_v2=(e,t,r,_,o,a)=>(na=n._sqlite3_create_collation_v2=i.se)(e,t,r,_,o,a),_a=n._sqlite3_create_collation16=(e,t,r,_,o)=>(_a=n._sqlite3_create_collation16=i.te)(e,t,r,_,o),sa=n._sqlite3_collation_needed=(e,t,r)=>(sa=n._sqlite3_collation_needed=i.ue)(e,t,r),oa=n._sqlite3_collation_needed16=(e,t,r)=>(oa=n._sqlite3_collation_needed16=i.ve)(e,t,r),ia=n._sqlite3_get_clientdata=(e,t)=>(ia=n._sqlite3_get_clientdata=i.we)(e,t),aa=n._sqlite3_set_clientdata=(e,t,r,_)=>(aa=n._sqlite3_set_clientdata=i.xe)(e,t,r,_),la=n._sqlite3_get_autocommit=e=>(la=n._sqlite3_get_autocommit=i.ye)(e),ca=n._sqlite3_table_column_metadata=(e,t,r,_,o,a,l,c,E)=>(ca=n._sqlite3_table_column_metadata=i.ze)(e,t,r,_,o,a,l,c,E),ua=n._sqlite3_sleep=e=>(ua=n._sqlite3_sleep=i.Ae)(e),fa=n._sqlite3_extended_result_codes=(e,t)=>(fa=n._sqlite3_extended_result_codes=i.Be)(e,t),da=n._sqlite3_file_control=(e,t,r,_)=>(da=n._sqlite3_file_control=i.Ce)(e,t,r,_),pa=n._sqlite3_test_control=(e,t)=>(pa=n._sqlite3_test_control=i.De)(e,t),va=n._sqlite3_create_filename=(e,t,r,_,o)=>(va=n._sqlite3_create_filename=i.Ee)(e,t,r,_,o),ma=n._sqlite3_free_filename=e=>(ma=n._sqlite3_free_filename=i.Fe)(e),Ea=n._sqlite3_uri_parameter=(e,t)=>(Ea=n._sqlite3_uri_parameter=i.Ge)(e,t),qa=n._sqlite3_uri_key=(e,t)=>(qa=n._sqlite3_uri_key=i.He)(e,t),ha=n._sqlite3_uri_boolean=(e,t,r)=>(ha=n._sqlite3_uri_boolean=i.Ie)(e,t,r),ba=n._sqlite3_uri_int64=(e,t,r,_)=>(ba=n._sqlite3_uri_int64=i.Je)(e,t,r,_),Ta=n._sqlite3_filename_database=e=>(Ta=n._sqlite3_filename_database=i.Ke)(e),wa=n._sqlite3_filename_journal=e=>(wa=n._sqlite3_filename_journal=i.Le)(e),ya=n._sqlite3_filename_wal=e=>(ya=n._sqlite3_filename_wal=i.Me)(e),Sa=n._sqlite3_db_name=(e,t)=>(Sa=n._sqlite3_db_name=i.Ne)(e,t),ga=n._sqlite3_db_filename=(e,t)=>(ga=n._sqlite3_db_filename=i.Oe)(e,t),Ia=n._sqlite3_db_readonly=(e,t)=>(Ia=n._sqlite3_db_readonly=i.Pe)(e,t),La=n._sqlite3_compileoption_used=e=>(La=n._sqlite3_compileoption_used=i.Qe)(e),xa=n._sqlite3_compileoption_get=e=>(xa=n._sqlite3_compileoption_get=i.Re)(e),Aa=n._sqlite3_sourceid=()=>(Aa=n._sqlite3_sourceid=i.Se)(),Na=n._malloc=e=>(Na=n._malloc=i.Te)(e),Ra=n._free=e=>(Ra=n._free=i.Ue)(e),ka=n._RegisterExtensionFunctions=e=>(ka=n._RegisterExtensionFunctions=i.Ve)(e),Oa=n._getSqliteFree=()=>(Oa=n._getSqliteFree=i.We)(),ct=n._main=(e,t)=>(ct=n._main=i.Xe)(e,t),Qa=n._libauthorizer_set_authorizer=(e,t,r)=>(Qa=n._libauthorizer_set_authorizer=i.Ye)(e,t,r),Ca=n._libfunction_create_function=(e,t,r,_,o,a,l,c)=>(Ca=n._libfunction_create_function=i.Ze)(e,t,r,_,o,a,l,c),Fa=n._libprogress_progress_handler=(e,t,r,_)=>(Fa=n._libprogress_progress_handler=i._e)(e,t,r,_),Pa=n._libvfs_vfs_register=(e,t,r,_,o,a)=>(Pa=n._libvfs_vfs_register=i.$e)(e,t,r,_,o,a),ut=(e,t)=>(ut=i.bf)(e,t),ft=()=>(ft=i.cf)(),dt=e=>(dt=i.df)(e),pt=e=>(pt=i.ef)(e),vt=()=>(vt=i.ff)(),Va=n._sqlite3_version=5472;n.getTempRet0=Un,n.ccall=Ee,n.cwrap=Mn,n.addFunction=Pn,n.setValue=Ae,n.getValue=$e,n.UTF8ToString=ce,n.stringToUTF8=oe,n.lengthBytesUTF8=pe,n.intArrayFromString=Me,n.intArrayToString=Gn,n.AsciiToString=Hn,n.UTF16ToString=Wn,n.stringToUTF16=zn,n.UTF32ToString=jn,n.stringToUTF32=Bn,n.writeArrayToMemory=it;var Re;be=function e(){Re||mt(),Re||(be=e)};function Da(){var e=ct,t=0,r=0;try{var _=e(t,r);return xn(_,!0),_}catch(o){return An(o)}}function mt(){if(le>0||(Ot(),le>0))return;function e(){Re||(Re=!0,n.calledRun=!0,!W&&(Qt(),Ct(),ie(n),n.onRuntimeInitialized?.(),Et&&Da(),Ft()))}n.setStatus?(n.setStatus("Running..."),setTimeout(function(){setTimeout(function(){n.setStatus("")},1),e()},1)):e()}if(n.preInit)for(typeof n.preInit=="function"&&(n.preInit=[n.preInit]);n.preInit.length>0;)n.preInit.pop()();var Et=!0;return n.noInitialRun&&(Et=!1),mt(),function(){let e=Object.getPrototypeOf(async function(){}).constructor,t=0;n.set_authorizer=function(r,_,o){t&&(n.deleteCallback(t),n._sqlite3_free(t),t=0),t=n._sqlite3_malloc(4),Ae(t,_ instanceof e?1:0,"i32");let a=Ee("libauthorizer_set_authorizer","number",["number","number","number"],[r,_?1:0,t]);return!a&&_&&n.setCallback(t,(l,c,E,h,g,A)=>_(o,c,E,h,g,A)),a}}(),function(){let e=Object.getPrototypeOf(async function(){}).constructor,t=["xFunc","xStep","xFinal"],r=new Map;n.create_function=function(_,o,a,l,c,E,h,g){let A=n._sqlite3_malloc(4),x={xFunc:E,xStep:h,xFinal:g};Ae(A,t.reduce((b,M,V)=>x[M]instanceof e?b|1<o(a))}}(),function(){let e=["xOpen","xDelete","xAccess","xFullPathname","xRandomness","xSleep","xCurrentTime","xGetLastError","xCurrentTimeInt64","xClose","xRead","xWrite","xTruncate","xSync","xFileSize","xLock","xUnlock","xCheckReservedLock","xFileControl","xSectorSize","xDeviceCharacteristics","xShmMap","xShmLock","xShmBarrier","xShmUnmap"],t=new Map;n.vfs_register=function(r,_){let o=0,a=0;e.forEach((c,E)=>{r[c]&&(o|=1<> 32n; + const hiMin = BigInt(Number.MIN_SAFE_INTEGER) >> 32n; + + return function(lo32, hi32) { + if (hi32 > hiMax || hi32 < hiMin) { + // Can't be expressed as a Number so use BigInt. + return cvt32x2ToBigInt(lo32, hi32); + } else { + // Combine the upper and lower 32-bit numbers. The complication is + // that lo32 is a signed integer which makes manipulating its bits + // a little tricky - the sign bit gets handled separately. + return (hi32 * 0x100000000) + (lo32 & 0x7fffffff) - (lo32 & 0x80000000); + } + } + })(); + + const databases = new Set(); + function verifyDatabase(db) { + if (!databases.has(db)) { + throw new SQLiteError('not a database', SQLITE_MISUSE); + } + } + + const mapStmtToDB = new Map(); + function verifyStatement(stmt) { + if (!mapStmtToDB.has(stmt)) { + throw new SQLiteError('not a statement', SQLITE_MISUSE); + } + } + + sqlite3.bind_collection = function(stmt, bindings) { + verifyStatement(stmt); + const isArray = Array.isArray(bindings); + const nBindings = sqlite3.bind_parameter_count(stmt); + for (let i = 1; i <= nBindings; ++i) { + const key = isArray ? i - 1 : sqlite3.bind_parameter_name(stmt, i); + const value = bindings[key]; + if (value !== undefined) { + sqlite3.bind(stmt, i, value); + } + } + return SQLITE_OK; + }; + + sqlite3.bind = function(stmt, i, value) { + verifyStatement(stmt); + switch (typeof value) { + case 'number': + if (value === (value | 0)) { + return sqlite3.bind_int(stmt, i, value); + } else { + return sqlite3.bind_double(stmt, i, value); + } + case 'string': + return sqlite3.bind_text(stmt, i, value); + default: + if (value instanceof Uint8Array || Array.isArray(value)) { + return sqlite3.bind_blob(stmt, i, value); + } else if (value === null) { + return sqlite3.bind_null(stmt, i); + } else if (typeof value === 'bigint') { + return sqlite3.bind_int64(stmt, i, value); + } else if (value === undefined) { + // Existing binding (or NULL) will be used. + return SQLITE_NOTICE; + } else { + console.warn('unknown binding converted to null', value); + return sqlite3.bind_null(stmt, i); + } + } + }; + + sqlite3.bind_blob = (function() { + const fname = 'sqlite3_bind_blob'; + const f = Module.cwrap(fname, ...decl('nnnnn:n')); + return function(stmt, i, value) { + verifyStatement(stmt); + // @ts-ignore + const byteLength = value.byteLength ?? value.length; + const ptr = Module._sqlite3_malloc(byteLength); + Module.HEAPU8.subarray(ptr).set(value); + const result = f(stmt, i, ptr, byteLength, sqliteFreeAddress); + return check(fname, result, mapStmtToDB.get(stmt)); + }; + })(); + + sqlite3.bind_parameter_count = (function() { + const fname = 'sqlite3_bind_parameter_count'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(stmt) { + verifyStatement(stmt); + const result = f(stmt); + return result; + }; + })(); + + sqlite3.bind_double = (function() { + const fname = 'sqlite3_bind_double'; + const f = Module.cwrap(fname, ...decl('nnn:n')); + return function(stmt, i, value) { + verifyStatement(stmt); + const result = f(stmt, i, value); + return check(fname, result, mapStmtToDB.get(stmt)); + }; + })(); + + sqlite3.bind_int = (function() { + const fname = 'sqlite3_bind_int'; + const f = Module.cwrap(fname, ...decl('nnn:n')); + return function(stmt, i, value) { + verifyStatement(stmt); + if (value > 0x7fffffff || value < -0x80000000) return SQLITE_RANGE; + + const result = f(stmt, i, value); + return check(fname, result, mapStmtToDB.get(stmt)); + }; + })(); + + sqlite3.bind_int64 = (function() { + const fname = 'sqlite3_bind_int64'; + const f = Module.cwrap(fname, ...decl('nnnn:n')); + return function(stmt, i, value) { + verifyStatement(stmt); + if (value > MAX_INT64 || value < MIN_INT64) return SQLITE_RANGE; + + const lo32 = value & 0xffffffffn; + const hi32 = value >> 32n; + const result = f(stmt, i, Number(lo32), Number(hi32)); + return check(fname, result, mapStmtToDB.get(stmt)); + }; + })(); + + sqlite3.bind_null = (function() { + const fname = 'sqlite3_bind_null'; + const f = Module.cwrap(fname, ...decl('nn:n')); + return function(stmt, i) { + verifyStatement(stmt); + const result = f(stmt, i); + return check(fname, result, mapStmtToDB.get(stmt)); + }; + })(); + + sqlite3.bind_parameter_name = (function() { + const fname = 'sqlite3_bind_parameter_name'; + const f = Module.cwrap(fname, ...decl('n:s')); + return function(stmt, i) { + verifyStatement(stmt); + const result = f(stmt, i); + return result; + }; + })(); + + sqlite3.bind_text = (function() { + const fname = 'sqlite3_bind_text'; + const f = Module.cwrap(fname, ...decl('nnnnn:n')); + return function(stmt, i, value) { + verifyStatement(stmt); + const ptr = createUTF8(value); + const result = f(stmt, i, ptr, -1, sqliteFreeAddress); + return check(fname, result, mapStmtToDB.get(stmt)); + }; + })(); + + sqlite3.changes = (function() { + const fname = 'sqlite3_changes'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(db) { + verifyDatabase(db); + const result = f(db); + return result; + }; + })(); + + sqlite3.close = (function() { + const fname = 'sqlite3_close'; + const f = Module.cwrap(fname, ...decl('n:n'), { async }); + return async function(db) { + verifyDatabase(db); + const result = await f(db); + databases.delete(db); + return check(fname, result, db); + }; + })(); + + sqlite3.column = function(stmt, iCol) { + verifyStatement(stmt); + const type = sqlite3.column_type(stmt, iCol); + switch (type) { + case SQLITE_BLOB: + return sqlite3.column_blob(stmt, iCol); + case SQLITE_FLOAT: + return sqlite3.column_double(stmt, iCol); + case SQLITE_INTEGER: + const lo32 = sqlite3.column_int(stmt, iCol); + const hi32 = Module.getTempRet0(); + return cvt32x2AsSafe(lo32, hi32); + case SQLITE_NULL: + return null; + case SQLITE_TEXT: + return sqlite3.column_text(stmt, iCol); + default: + throw new SQLiteError('unknown type', type); + } + }; + + sqlite3.column_blob = (function() { + const fname = 'sqlite3_column_blob'; + const f = Module.cwrap(fname, ...decl('nn:n')); + return function(stmt, iCol) { + verifyStatement(stmt); + const nBytes = sqlite3.column_bytes(stmt, iCol); + const address = f(stmt, iCol); + const result = Module.HEAPU8.subarray(address, address + nBytes); + return result; + }; + })(); + + sqlite3.column_bytes = (function() { + const fname = 'sqlite3_column_bytes'; + const f = Module.cwrap(fname, ...decl('nn:n')); + return function(stmt, iCol) { + verifyStatement(stmt); + const result = f(stmt, iCol); + return result; + }; + })(); + + sqlite3.column_count = (function() { + const fname = 'sqlite3_column_count'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(stmt) { + verifyStatement(stmt); + const result = f(stmt); + return result; + }; + })(); + + sqlite3.column_double = (function() { + const fname = 'sqlite3_column_double'; + const f = Module.cwrap(fname, ...decl('nn:n')); + return function(stmt, iCol) { + verifyStatement(stmt); + const result = f(stmt, iCol); + return result; + }; + })(); + + sqlite3.column_int = (function() { + // Retrieve int64 but use only the lower 32 bits. The upper 32-bits are + // accessible with Module.getTempRet0(). + const fname = 'sqlite3_column_int64'; + const f = Module.cwrap(fname, ...decl('nn:n')); + return function(stmt, iCol) { + verifyStatement(stmt); + const result = f(stmt, iCol); + return result; + }; + })(); + + sqlite3.column_int64 = (function() { + const fname = 'sqlite3_column_int64'; + const f = Module.cwrap(fname, ...decl('nn:n')); + return function(stmt, iCol) { + verifyStatement(stmt); + const lo32 = f(stmt, iCol); + const hi32 = Module.getTempRet0(); + const result = cvt32x2ToBigInt(lo32, hi32); + return result; + }; + })(); + + sqlite3.column_name = (function() { + const fname = 'sqlite3_column_name'; + const f = Module.cwrap(fname, ...decl('nn:s')); + return function(stmt, iCol) { + verifyStatement(stmt); + const result = f(stmt, iCol); + return result; + }; + })(); + + sqlite3.column_names = function(stmt) { + const columns = []; + const nColumns = sqlite3.column_count(stmt); + for (let i = 0; i < nColumns; ++i) { + columns.push(sqlite3.column_name(stmt, i)); + } + return columns; + }; + + sqlite3.column_text = (function() { + const fname = 'sqlite3_column_text'; + const f = Module.cwrap(fname, ...decl('nn:s')); + return function(stmt, iCol) { + verifyStatement(stmt); + const result = f(stmt, iCol); + return result; + }; + })(); + + sqlite3.column_type = (function() { + const fname = 'sqlite3_column_type'; + const f = Module.cwrap(fname, ...decl('nn:n')); + return function(stmt, iCol) { + verifyStatement(stmt); + const result = f(stmt, iCol); + return result; + }; + })(); + + sqlite3.create_function = function(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal) { + verifyDatabase(db); + + // Convert SQLite callback arguments to JavaScript-friendly arguments. + function adapt(f) { + return f instanceof AsyncFunction ? + (async (ctx, n, values) => f(ctx, Module.HEAP32.subarray(values / 4, values / 4 + n))) : + ((ctx, n, values) => f(ctx, Module.HEAP32.subarray(values / 4, values / 4 + n))); + } + + const result = Module.create_function( + db, + zFunctionName, + nArg, + eTextRep, + pApp, + xFunc && adapt(xFunc), + xStep && adapt(xStep), + xFinal); + return check('sqlite3_create_function', result, db); + }; + + sqlite3.data_count = (function() { + const fname = 'sqlite3_data_count'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(stmt) { + verifyStatement(stmt); + const result = f(stmt); + return result; + }; + })(); + + sqlite3.exec = async function(db, sql, callback) { + for await (const stmt of sqlite3.statements(db, sql)) { + let columns; + while (await sqlite3.step(stmt) === SQLITE_ROW) { + if (callback) { + columns = columns ?? sqlite3.column_names(stmt); + const row = sqlite3.row(stmt); + await callback(row, columns); + } + } + } + return SQLITE_OK; + }; + + sqlite3.finalize = (function() { + const fname = 'sqlite3_finalize'; + const f = Module.cwrap(fname, ...decl('n:n'), { async }); + return async function(stmt) { + const result = await f(stmt); + mapStmtToDB.delete(stmt); + + // Don't throw on error here. Typically the error has already been + // thrown and finalize() is part of the cleanup. + return result; + }; + })(); + + sqlite3.get_autocommit = (function() { + const fname = 'sqlite3_get_autocommit'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(db) { + const result = f(db); + return result; + }; + })(); + + sqlite3.libversion = (function() { + const fname = 'sqlite3_libversion'; + const f = Module.cwrap(fname, ...decl(':s')); + return function() { + const result = f(); + return result; + }; + })(); + + sqlite3.libversion_number = (function() { + const fname = 'sqlite3_libversion_number'; + const f = Module.cwrap(fname, ...decl(':n')); + return function() { + const result = f(); + return result; + }; + })(); + + sqlite3.limit = (function() { + const fname = 'sqlite3_limit'; + const f = Module.cwrap(fname, ...decl('nnn:n')); + return function(db, id, newVal) { + const result = f(db, id, newVal); + return result; + }; + })(); + + sqlite3.open_v2 = (function() { + const fname = 'sqlite3_open_v2'; + const f = Module.cwrap(fname, ...decl('snnn:n'), { async }); + return async function(zFilename, flags, zVfs) { + flags = flags || SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE; + zVfs = createUTF8(zVfs); + try { + // Allow retry operations. + const rc = await retry(() => f(zFilename, tmpPtr[0], flags, zVfs)); + + const db = Module.getValue(tmpPtr[0], '*'); + databases.add(db); + + Module.ccall('RegisterExtensionFunctions', 'void', ['number'], [db]); + check(fname, rc); + return db; + } finally { + Module._sqlite3_free(zVfs); + } + }; + })(); + + sqlite3.progress_handler = function(db, nProgressOps, handler, userData) { + verifyDatabase(db); + Module.progress_handler(db, nProgressOps, handler, userData); + }; + sqlite3.reset = (function() { + const fname = 'sqlite3_reset'; + const f = Module.cwrap(fname, ...decl('n:n'), { async }); + return async function(stmt) { + verifyStatement(stmt); + const result = await f(stmt); + return check(fname, result, mapStmtToDB.get(stmt)); + }; + })(); + + sqlite3.result = function(context, value) { + switch (typeof value) { + case 'number': + if (value === (value | 0)) { + sqlite3.result_int(context, value); + } else { + sqlite3.result_double(context, value); + } + break; + case 'string': + sqlite3.result_text(context, value); + break; + default: + if (value instanceof Uint8Array || Array.isArray(value)) { + sqlite3.result_blob(context, value); + } else if (value === null) { + sqlite3.result_null(context); + } else if (typeof value === 'bigint') { + return sqlite3.result_int64(context, value); + } else { + console.warn('unknown result converted to null', value); + sqlite3.result_null(context); + } + break; + } + + }; + + sqlite3.result_blob = (function() { + const fname = 'sqlite3_result_blob'; + const f = Module.cwrap(fname, ...decl('nnnn:n')); + return function(context, value) { + // @ts-ignore + const byteLength = value.byteLength ?? value.length; + const ptr = Module._sqlite3_malloc(byteLength); + Module.HEAPU8.subarray(ptr).set(value); + f(context, ptr, byteLength, sqliteFreeAddress); // void return + }; + })(); + + sqlite3.result_double = (function() { + const fname = 'sqlite3_result_double'; + const f = Module.cwrap(fname, ...decl('nn:n')); + return function(context, value) { + f(context, value); // void return + }; + })(); + + sqlite3.result_int = (function() { + const fname = 'sqlite3_result_int'; + const f = Module.cwrap(fname, ...decl('nn:n')); + return function(context, value) { + f(context, value); // void return + }; + })(); + + sqlite3.result_int64 = (function() { + const fname = 'sqlite3_result_int64'; + const f = Module.cwrap(fname, ...decl('nnn:n')); + return function(context, value) { + if (value > MAX_INT64 || value < MIN_INT64) return SQLITE_RANGE; + + const lo32 = value & 0xffffffffn; + const hi32 = value >> 32n; + f(context, Number(lo32), Number(hi32)); // void return + }; + })(); + + sqlite3.result_null = (function() { + const fname = 'sqlite3_result_null'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(context) { + f(context); // void return + }; + })(); + + sqlite3.result_text = (function() { + const fname = 'sqlite3_result_text'; + const f = Module.cwrap(fname, ...decl('nnnn:n')); + return function(context, value) { + const ptr = createUTF8(value); + f(context, ptr, -1, sqliteFreeAddress); // void return + }; + })(); + + sqlite3.row = function(stmt) { + const row = []; + const nColumns = sqlite3.data_count(stmt); + for (let i = 0; i < nColumns; ++i) { + const value = sqlite3.column(stmt, i); + + // Copy blob if aliasing volatile WebAssembly memory. This avoids an + // unnecessary copy if users monkey patch column_blob to copy. + // @ts-ignore + row.push(value?.buffer === Module.HEAPU8.buffer ? value.slice() : value); + } + return row; + }; + + sqlite3.set_authorizer = function(db, xAuth, pApp) { + verifyDatabase(db); + + // Convert SQLite callback arguments to JavaScript-friendly arguments. + function cvtArgs(_, iAction, p3, p4, p5, p6) { + return [ + _, + iAction, + Module.UTF8ToString(p3), + Module.UTF8ToString(p4), + Module.UTF8ToString(p5), + Module.UTF8ToString(p6) + ]; + } function adapt(f) { + return f instanceof AsyncFunction ? + (async (_, iAction, p3, p4, p5, p6) => f(cvtArgs(_, iAction, p3, p4, p5, p6))) : + ((_, iAction, p3, p4, p5, p6) => f(cvtArgs(_, iAction, p3, p4, p5, p6))); + } + + const result = Module.set_authorizer(db, adapt(xAuth), pApp); + return check('sqlite3_set_authorizer', result, db); + }; + sqlite3.sql = (function() { + const fname = 'sqlite3_sql'; + const f = Module.cwrap(fname, ...decl('n:s')); + return function(stmt) { + verifyStatement(stmt); + const result = f(stmt); + return result; + }; + })(); + + sqlite3.statements = function(db, sql, options = {}) { + const prepare = Module.cwrap( + 'sqlite3_prepare_v3', + 'number', + ['number', 'number', 'number', 'number', 'number', 'number'], + { async: true }); + + return (async function*() { + const onFinally = []; + try { + // Encode SQL string to UTF-8. + const utf8 = new TextEncoder().encode(sql); + + // Copy encoded string to WebAssembly memory. The SQLite docs say + // zero-termination is a minor optimization so add room for that. + // Also add space for the statement handle and SQL tail pointer. + const allocSize = utf8.byteLength - (utf8.byteLength % 4) + 12; + const pzHead = Module._sqlite3_malloc(allocSize); + const pzEnd = pzHead + utf8.byteLength + 1; + onFinally.push(() => Module._sqlite3_free(pzHead)); + Module.HEAPU8.set(utf8, pzHead); + Module.HEAPU8[pzEnd - 1] = 0; + + // Use extra space for the statement handle and SQL tail pointer. + const pStmt = pzHead + allocSize - 8; + const pzTail = pzHead + allocSize - 4; + + // Ensure that statement handles are not leaked. + let stmt; + function maybeFinalize() { + if (stmt && !options.unscoped) { + sqlite3.finalize(stmt); + } + stmt = 0; + } + onFinally.push(maybeFinalize); + + // Loop over statements. + Module.setValue(pzTail, pzHead, '*'); + do { + // Reclaim resources for the previous iteration. + maybeFinalize(); + + // Call sqlite3_prepare_v3() for the next statement. + // Allow retry operations. + const zTail = Module.getValue(pzTail, '*'); + const rc = await retry(() => { + return prepare( + db, + zTail, + pzEnd - pzTail, + options.flags || 0, + pStmt, + pzTail); + }); + + if (rc !== SQLITE_OK) { + check('sqlite3_prepare_v3', rc, db); + } + + stmt = Module.getValue(pStmt, '*'); + if (stmt) { + mapStmtToDB.set(stmt, db); + yield stmt; + } + } while (stmt); + } finally { + while (onFinally.length) { + onFinally.pop()(); + } + } + })(); + }; + + sqlite3.step = (function() { + const fname = 'sqlite3_step'; + const f = Module.cwrap(fname, ...decl('n:n'), { async }); + return async function(stmt) { + verifyStatement(stmt); + + // Allow retry operations. + const rc = await retry(() => f(stmt)); + + return check(fname, rc, mapStmtToDB.get(stmt), [SQLITE_ROW, SQLITE_DONE]); + }; + })(); + + sqlite3.value = function(pValue) { + const type = sqlite3.value_type(pValue); + switch (type) { + case SQLITE_BLOB: + return sqlite3.value_blob(pValue); + case SQLITE_FLOAT: + return sqlite3.value_double(pValue); + case SQLITE_INTEGER: + const lo32 = sqlite3.value_int(pValue); + const hi32 = Module.getTempRet0(); + return cvt32x2AsSafe(lo32, hi32); + case SQLITE_NULL: + return null; + case SQLITE_TEXT: + return sqlite3.value_text(pValue); + default: + throw new SQLiteError('unknown type', type); + } + }; + + sqlite3.value_blob = (function() { + const fname = 'sqlite3_value_blob'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(pValue) { + const nBytes = sqlite3.value_bytes(pValue); + const address = f(pValue); + const result = Module.HEAPU8.subarray(address, address + nBytes); + return result; + }; + })(); + + sqlite3.value_bytes = (function() { + const fname = 'sqlite3_value_bytes'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(pValue) { + const result = f(pValue); + return result; + }; + })(); + + sqlite3.value_double = (function() { + const fname = 'sqlite3_value_double'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(pValue) { + const result = f(pValue); + return result; + }; + })(); + + sqlite3.value_int = (function() { + const fname = 'sqlite3_value_int64'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(pValue) { + const result = f(pValue); + return result; + }; + })(); + + sqlite3.value_int64 = (function() { + const fname = 'sqlite3_value_int64'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(pValue) { + const lo32 = f(pValue); + const hi32 = Module.getTempRet0(); + const result = cvt32x2ToBigInt(lo32, hi32); + return result; + }; + })(); + + sqlite3.value_text = (function() { + const fname = 'sqlite3_value_text'; + const f = Module.cwrap(fname, ...decl('n:s')); + return function(pValue) { + const result = f(pValue); + return result; + }; + })(); + + sqlite3.value_type = (function() { + const fname = 'sqlite3_value_type'; + const f = Module.cwrap(fname, ...decl('n:n')); + return function(pValue) { + const result = f(pValue); + return result; + }; + })(); + + sqlite3.vfs_register = function(vfs, makeDefault) { + const result = Module.vfs_register(vfs, makeDefault); + return check('sqlite3_vfs_register', result); + }; + + function check(fname, result, db = null, allowed = [SQLITE_OK]) { + if (allowed.includes(result)) return result; + const message = db ? + Module.ccall('sqlite3_errmsg', 'string', ['number'], [db]) : + fname; + throw new SQLiteError(message, result); + } + + // This function is used to automatically retry failed calls that + // have pending retry operations that should allow the retry to + // succeed. + async function retry(f) { + let rc; + do { + // Wait for all pending retry operations to complete. This is + // normally empty on the first loop iteration. + if (Module.retryOps.length) { + await Promise.all(Module.retryOps); + Module.retryOps = []; + } + + rc = await f(); + + // Retry on failure with new pending retry operations. + } while (rc && Module.retryOps.length); + return rc; + } + + return sqlite3; +} + +// Helper function to use a more compact signature specification. +function decl(s) { + const result = []; + const m = s.match(/([ns@]*):([nsv@])/); + switch (m[2]) { + case 'n': result.push('number'); break; + case 's': result.push('string'); break; + case 'v': result.push(null); break; + } + + const args = []; + for (let c of m[1]) { + switch (c) { + case 'n': args.push('number'); break; + case 's': args.push('string'); break; + } + } + result.push(args); + return result; +} + +var Module = (() => { + var _scriptName = import.meta.url; + + return ( +function(moduleArg = {}) { + var moduleRtn; + +var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;var readyPromise=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject;});var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof importScripts=="function";typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";var moduleOverrides=Object.assign({},Module);var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href;}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src;}if(_scriptName){scriptDirectory=_scriptName;}if(scriptDirectory.startsWith("blob:")){scriptDirectory="";}else {scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1);}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)};}readAsync=url=>fetch(url,{credentials:"same-origin"}).then(response=>{if(response.ok){return response.arrayBuffer()}return Promise.reject(new Error(response.status+" : "+response.url))});}}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.error.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["quit"])quit_=Module["quit"];var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];var wasmMemory;var ABORT=false;var EXITSTATUS;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;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);}var __ATPRERUN__=[];var __ATINIT__=[];var __ATMAIN__=[];var __ATPOSTRUN__=[];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(){if(!Module["noFSInit"]&&!FS.init.initialized)FS.init();FS.ignorePermissions=false;callRuntimeCallbacks(__ATINIT__);}function preMain(){callRuntimeCallbacks(__ATMAIN__);}function postRun(){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 addOnPostRun(cb){__ATPOSTRUN__.unshift(cb);}var runDependencies=0;var dependenciesFulfilled=null;function getUniqueRunDependency(id){return id}function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies);}function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback();}}}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;EXITSTATUS=1;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";var isDataURI=filename=>filename.startsWith(dataURIPrefix);function findWasmBinary(){if(Module["locateFile"]){var f="wa-sqlite.wasm";if(!isDataURI(f)){return locateFile(f)}return f}return new URL("wa-sqlite.wasm",import.meta.url).href}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(!wasmBinary){return readAsync(binaryFile).then(response=>new Uint8Array(response),()=>getBinarySync(binaryFile))}return Promise.resolve().then(()=>getBinarySync(binaryFile))}function instantiateArrayBuffer(binaryFile,imports,receiver){return getBinaryPromise(binaryFile).then(binary=>WebAssembly.instantiate(binary,imports)).then(receiver,reason=>{err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason);})}function instantiateAsync(binary,binaryFile,imports,callback){if(!binary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(binaryFile)&&typeof fetch=="function"){return fetch(binaryFile,{credentials:"same-origin"}).then(response=>{var result=WebAssembly.instantiateStreaming(response,imports);return result.then(callback,function(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(binaryFile,imports,callback)})})}return instantiateArrayBuffer(binaryFile,imports,callback)}function getWasmImports(){return {a:wasmImports}}function createWasm(){var info=getWasmImports();function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["ja"];updateMemoryViews();wasmTable=wasmExports["af"];addOnInit(wasmExports["ka"]);removeRunDependency();return wasmExports}addRunDependency();function receiveInstantiationResult(result){receiveInstance(result["instance"]);}if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err(`Module.instantiateWasm callback failed with error: ${e}`);readyPromiseReject(e);}}if(!wasmBinaryFile)wasmBinaryFile=findWasmBinary();instantiateAsync(wasmBinary,wasmBinaryFile,info,receiveInstantiationResult).catch(readyPromiseReject);return {}}var tempDouble;var tempI64;function ExitStatus(status){this.name="ExitStatus";this.message=`Program terminated with exit(${status})`;this.status=status;}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module);}};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;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 UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder:undefined;var UTF8ArrayToString=(heapOrArray,idx,maxBytesToRead)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023);}}return str};var UTF8ToString=(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):"";var ___assert_fail=(condition,filename,line,func)=>{abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"]);};var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(parts,allowAboveRoot)=>{var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1);}else if(last===".."){parts.splice(i,1);up++;}else if(up){parts.splice(i,1);up--;}}if(allowAboveRoot){for(;up;up--){parts.unshift("..");}}return parts},normalize:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.substr(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path=".";}if(path&&trailingSlash){path+="/";}return (isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return "."}if(dir){dir=dir.substr(0,dir.length-1);}return root+dir},basename:path=>{if(path==="/")return "/";path=PATH.normalize(path);path=path.replace(/\/$/,"");var lastSlash=path.lastIndexOf("/");if(lastSlash===-1)return path;return path.substr(lastSlash+1)},join:(...paths)=>PATH.normalize(paths.join("/")),join2:(l,r)=>PATH.normalize(l+"/"+r)};var initRandomFill=()=>{if(typeof crypto=="object"&&typeof crypto["getRandomValues"]=="function"){return view=>crypto.getRandomValues(view)}else abort("initRandomDevice");};var randomFill=view=>(randomFill=initRandomFill())(view);var PATH_FS={resolve:(...args)=>{var resolvedPath="",resolvedAbsolute=false;for(var i=args.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?args[i]:FS.cwd();if(typeof path!="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){return ""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=PATH.isAbs(path);}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return (resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).substr(1);to=PATH_FS.resolve(to).substr(1);function trim(arr){var start=0;for(;start=0;end--){if(arr[end]!=="")break}if(start>end)return [];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i{var len=0;for(var i=0;i=55296&&c<=57343){len+=4;++i;}else {len+=3;}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023;}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u;}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63;}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;}else {if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;}}heap[outIdx]=0;return outIdx-startIdx};function intArrayFromString(stringy,dontAddNull,length){var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array}var FS_stdin_getChar=()=>{if(!FS_stdin_getChar_buffer.length){var result=null;if(typeof window!="undefined"&&typeof window.prompt=="function"){result=window.prompt("Input: ");if(result!==null){result+="\n";}}if(!result){return null}FS_stdin_getChar_buffer=intArrayFromString(result,true);}return FS_stdin_getChar_buffer.shift()};var TTY={ttys:[],init(){},shutdown(){},register(dev,ops){TTY.ttys[dev]={input:[],output:[],ops:ops};FS.registerDevice(dev,TTY.stream_ops);},stream_ops:{open(stream){var tty=TTY.ttys[stream.node.rdev];if(!tty){throw new FS.ErrnoError(43)}stream.tty=tty;stream.seekable=false;},close(stream){stream.tty.ops.fsync(stream.tty);},fsync(stream){stream.tty.ops.fsync(stream.tty);},read(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(60)}var bytesRead=0;for(var i=0;i0){out(UTF8ArrayToString(tty.output,0));tty.output=[];}},ioctl_tcgets(tty){return {c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(tty,optional_actions,data){return 0},ioctl_tiocgwinsz(tty){return [24,80]}},default_tty1_ops:{put_char(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output,0));tty.output=[];}else {if(val!=0)tty.output.push(val);}},fsync(tty){if(tty.output&&tty.output.length>0){err(UTF8ArrayToString(tty.output,0));tty.output=[];}}}};var zeroMemory=(address,size)=>{HEAPU8.fill(0,address,address+size);return address};var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var mmapAlloc=size=>{size=alignMemory(size,65536);var ptr=_emscripten_builtin_memalign(65536,size);if(!ptr)return 0;return zeroMemory(ptr,size)};var MEMFS={ops_table:null,mount(mount){return MEMFS.createNode(null,"/",16384|511,0)},createNode(parent,name,mode,dev){if(FS.isBlkdev(mode)||FS.isFIFO(mode)){throw new FS.ErrnoError(63)}MEMFS.ops_table||={dir:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,lookup:MEMFS.node_ops.lookup,mknod:MEMFS.node_ops.mknod,rename:MEMFS.node_ops.rename,unlink:MEMFS.node_ops.unlink,rmdir:MEMFS.node_ops.rmdir,readdir:MEMFS.node_ops.readdir,symlink:MEMFS.node_ops.symlink},stream:{llseek:MEMFS.stream_ops.llseek}},file:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:{llseek:MEMFS.stream_ops.llseek,read:MEMFS.stream_ops.read,write:MEMFS.stream_ops.write,allocate:MEMFS.stream_ops.allocate,mmap:MEMFS.stream_ops.mmap,msync:MEMFS.stream_ops.msync}},link:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,readlink:MEMFS.node_ops.readlink},stream:{}},chrdev:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:FS.chrdev_stream_ops}};var node=FS.createNode(parent,name,mode,dev);if(FS.isDir(node.mode)){node.node_ops=MEMFS.ops_table.dir.node;node.stream_ops=MEMFS.ops_table.dir.stream;node.contents={};}else if(FS.isFile(node.mode)){node.node_ops=MEMFS.ops_table.file.node;node.stream_ops=MEMFS.ops_table.file.stream;node.usedBytes=0;node.contents=null;}else if(FS.isLink(node.mode)){node.node_ops=MEMFS.ops_table.link.node;node.stream_ops=MEMFS.ops_table.link.stream;}else if(FS.isChrdev(node.mode)){node.node_ops=MEMFS.ops_table.chrdev.node;node.stream_ops=MEMFS.ops_table.chrdev.stream;}node.timestamp=Date.now();if(parent){parent.contents[name]=node;parent.timestamp=node.timestamp;}return node},getFileDataAsTypedArray(node){if(!node.contents)return new Uint8Array(0);if(node.contents.subarray)return node.contents.subarray(0,node.usedBytes);return new Uint8Array(node.contents)},expandFileStorage(node,newCapacity){var prevCapacity=node.contents?node.contents.length:0;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity>>0);if(prevCapacity!=0)newCapacity=Math.max(newCapacity,256);var oldContents=node.contents;node.contents=new Uint8Array(newCapacity);if(node.usedBytes>0)node.contents.set(oldContents.subarray(0,node.usedBytes),0);},resizeFileStorage(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0;}else {var oldContents=node.contents;node.contents=new Uint8Array(newSize);if(oldContents){node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)));}node.usedBytes=newSize;}},node_ops:{getattr(node){var attr={};attr.dev=FS.isChrdev(node.mode)?node.id:1;attr.ino=node.id;attr.mode=node.mode;attr.nlink=1;attr.uid=0;attr.gid=0;attr.rdev=node.rdev;if(FS.isDir(node.mode)){attr.size=4096;}else if(FS.isFile(node.mode)){attr.size=node.usedBytes;}else if(FS.isLink(node.mode)){attr.size=node.link.length;}else {attr.size=0;}attr.atime=new Date(node.timestamp);attr.mtime=new Date(node.timestamp);attr.ctime=new Date(node.timestamp);attr.blksize=4096;attr.blocks=Math.ceil(attr.size/attr.blksize);return attr},setattr(node,attr){if(attr.mode!==undefined){node.mode=attr.mode;}if(attr.timestamp!==undefined){node.timestamp=attr.timestamp;}if(attr.size!==undefined){MEMFS.resizeFileStorage(node,attr.size);}},lookup(parent,name){throw FS.genericErrors[44]},mknod(parent,name,mode,dev){return MEMFS.createNode(parent,name,mode,dev)},rename(old_node,new_dir,new_name){if(FS.isDir(old_node.mode)){var new_node;try{new_node=FS.lookupNode(new_dir,new_name);}catch(e){}if(new_node){for(var i in new_node.contents){throw new FS.ErrnoError(55)}}}delete old_node.parent.contents[old_node.name];old_node.parent.timestamp=Date.now();old_node.name=new_name;new_dir.contents[new_name]=old_node;new_dir.timestamp=old_node.parent.timestamp;},unlink(parent,name){delete parent.contents[name];parent.timestamp=Date.now();},rmdir(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(55)}delete parent.contents[name];parent.timestamp=Date.now();},readdir(node){var entries=[".",".."];for(var key of Object.keys(node.contents)){entries.push(key);}return entries},symlink(parent,newname,oldpath){var node=MEMFS.createNode(parent,newname,511|40960,0);node.link=oldpath;return node},readlink(node){if(!FS.isLink(node.mode)){throw new FS.ErrnoError(28)}return node.link}},stream_ops:{read(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=stream.node.usedBytes)return 0;var size=Math.min(stream.node.usedBytes-position,length);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset);}else {for(var i=0;i0||position+length{var dep=getUniqueRunDependency(`al ${url}`);readAsync(url).then(arrayBuffer=>{onload(new Uint8Array(arrayBuffer));if(dep)removeRunDependency();},err=>{if(onerror){onerror();}else {throw `Loading data file "${url}" failed.`}});if(dep)addRunDependency();};var FS_createDataFile=(parent,name,fileData,canRead,canWrite,canOwn)=>{FS.createDataFile(parent,name,fileData,canRead,canWrite,canOwn);};var preloadPlugins=Module["preloadPlugins"]||[];var FS_handledByPreloadPlugin=(byteArray,fullname,finish,onerror)=>{if(typeof Browser!="undefined")Browser.init();var handled=false;preloadPlugins.forEach(plugin=>{if(handled)return;if(plugin["canHandle"](fullname)){plugin["handle"](byteArray,fullname,finish,onerror);handled=true;}});return handled};var FS_createPreloadedFile=(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish)=>{var fullname=name?PATH_FS.resolve(PATH.join2(parent,name)):parent;function processData(byteArray){function finish(byteArray){preFinish?.();if(!dontCreateFile){FS_createDataFile(parent,name,byteArray,canRead,canWrite,canOwn);}onload?.();removeRunDependency();}if(FS_handledByPreloadPlugin(byteArray,fullname,finish,()=>{onerror?.();removeRunDependency();})){return}finish(byteArray);}addRunDependency();if(typeof url=="string"){asyncLoad(url,processData,onerror);}else {processData(url);}};var FS_modeStringToFlags=str=>{var flagModes={r:0,"r+":2,w:512|64|1,"w+":512|64|2,a:1024|64|1,"a+":1024|64|2};var flags=flagModes[str];if(typeof flags=="undefined"){throw new Error(`Unknown file open mode: ${str}`)}return flags};var FS_getMode=(canRead,canWrite)=>{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:class{constructor(errno){this.name="ErrnoError";this.errno=errno;}},genericErrors:{},filesystems:null,syncFSRequests:0,FSStream:class{constructor(){this.shared={};}get object(){return this.node}set object(val){this.node=val;}get isRead(){return (this.flags&2097155)!==1}get isWrite(){return (this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(val){this.shared.flags=val;}get position(){return this.shared.position}set position(val){this.shared.position=val;}},FSNode:class{constructor(parent,name,mode,rdev){if(!parent){parent=this;}this.parent=parent;this.mount=parent.mount;this.mounted=null;this.id=FS.nextInode++;this.name=name;this.mode=mode;this.node_ops={};this.stream_ops={};this.rdev=rdev;this.readMode=292|73;this.writeMode=146;}get read(){return (this.mode&this.readMode)===this.readMode}set read(val){val?this.mode|=this.readMode:this.mode&=~this.readMode;}get write(){return (this.mode&this.writeMode)===this.writeMode}set write(val){val?this.mode|=this.writeMode:this.mode&=~this.writeMode;}get isFolder(){return FS.isDir(this.mode)}get isDevice(){return FS.isChrdev(this.mode)}},lookupPath(path,opts={}){path=PATH_FS.resolve(path);if(!path)return {path:"",node:null};var defaults={follow_mount:true,recurse_count:0};opts=Object.assign(defaults,opts);if(opts.recurse_count>8){throw new FS.ErrnoError(32)}var parts=path.split("/").filter(p=>!!p);var current=FS.root;var current_path="/";for(var i=0;i40){throw new FS.ErrnoError(32)}}}}return {path:current_path,node:current}},getPath(node){var path;while(true){if(FS.isRoot(node)){var mount=node.mount.mountpoint;if(!path)return mount;return mount[mount.length-1]!=="/"?`${mount}/${path}`:mount+path}path=path?`${node.name}/${path}`:node.name;node=node.parent;}},hashName(parentid,name){var hash=0;for(var i=0;i>>0)%FS.nameTable.length},hashAddNode(node){var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node;},hashRemoveNode(node){var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next;}else {var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next;}}},lookupNode(parent,name){var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode)}var hash=FS.hashName(parent.id,name);for(var node=FS.nameTable[hash];node;node=node.name_next){var nodeName=node.name;if(node.parent.id===parent.id&&nodeName===name){return node}}return FS.lookup(parent,name)},createNode(parent,name,mode,rdev){var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode(node){FS.hashRemoveNode(node);},isRoot(node){return node===node.parent},isMountpoint(node){return !!node.mounted},isFile(mode){return (mode&61440)===32768},isDir(mode){return (mode&61440)===16384},isLink(mode){return (mode&61440)===40960},isChrdev(mode){return (mode&61440)===8192},isBlkdev(mode){return (mode&61440)===24576},isFIFO(mode){return (mode&61440)===4096},isSocket(mode){return (mode&49152)===49152},flagsToPermissionString(flag){var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w";}return perms},nodePermissions(node,perms){if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup(dir){if(!FS.isDir(dir.mode))return 54;var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate(dir,name){try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete(dir,name,isdir){var node;try{node=FS.lookupNode(dir,name);}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else {if(FS.isDir(node.mode)){return 31}}return 0},mayOpen(node,flags){if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&512){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},MAX_OPEN_FDS:4096,nextfd(){for(var fd=0;fd<=FS.MAX_OPEN_FDS;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(33)},getStreamChecked(fd){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}return stream},getStream:fd=>FS.streams[fd],createStream(stream,fd=-1){stream=Object.assign(new FS.FSStream,stream);if(fd==-1){fd=FS.nextfd();}stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream(fd){FS.streams[fd]=null;},dupStream(origStream,fd=-1){var stream=FS.createStream(origStream,fd);stream.stream_ops?.dup?.(stream);return stream},chrdev_stream_ops:{open(stream){var device=FS.getDevice(stream.node.rdev);stream.stream_ops=device.stream_ops;stream.stream_ops.open?.(stream);},llseek(){throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice(dev,ops){FS.devices[dev]={stream_ops:ops};},getDevice:dev=>FS.devices[dev],getMounts(mount){var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push(...m.mounts);}return mounts},syncfs(populate,callback){if(typeof populate=="function"){callback=populate;populate=false;}FS.syncFSRequests++;if(FS.syncFSRequests>1){err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null);}}mounts.forEach(mount=>{if(!mount.type.syncfs){return done(null)}mount.type.syncfs(mount,populate,done);});},mount(type,opts,mountpoint){var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;node=lookup.node;if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}}var mount={type:type,opts:opts,mountpoint:mountpoint,mounts:[]};var mountRoot=type.mount(mount);mountRoot.mount=mount;mount.root=mountRoot;if(root){FS.root=mountRoot;}else if(node){node.mounted=mount;if(node.mount){node.mount.mounts.push(mount);}}return mountRoot},unmount(mountpoint){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(28)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);Object.keys(FS.nameTable).forEach(hash=>{var current=FS.nameTable[hash];while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current);}current=next;}});node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1);},lookup(parent,name){return parent.node_ops.lookup(parent,name)},mknod(path,mode,dev){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name||name==="."||name===".."){throw new FS.ErrnoError(28)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},create(path,mode){mode=mode!==undefined?mode:438;mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir(path,mode){mode=mode!==undefined?mode:511;mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree(path,mode){var dirs=path.split("/");var d="";for(var i=0;iFS.currentPath,chdir(path){var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path;},createDefaultDirectories(){FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user");},createDefaultDevices(){FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>length});FS.mkdev("/dev/null",FS.makedev(1,3));TTY.register(FS.makedev(5,0),TTY.default_tty_ops);TTY.register(FS.makedev(6,0),TTY.default_tty1_ops);FS.mkdev("/dev/tty",FS.makedev(5,0));FS.mkdev("/dev/tty1",FS.makedev(6,0));var randomBuffer=new Uint8Array(1024),randomLeft=0;var randomByte=()=>{if(randomLeft===0){randomLeft=randomFill(randomBuffer).byteLength;}return randomBuffer[--randomLeft]};FS.createDevice("/dev","random",randomByte);FS.createDevice("/dev","urandom",randomByte);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp");},createSpecialDirectories(){FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount(){var node=FS.createNode(proc_self,"fd",16384|511,73);node.node_ops={lookup(parent,name){var fd=+name;var stream=FS.getStreamChecked(fd);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>stream.path}};ret.parent=ret;return ret}};return node}},{},"/proc/self/fd");},createStandardStreams(){if(Module["stdin"]){FS.createDevice("/dev","stdin",Module["stdin"]);}else {FS.symlink("/dev/tty","/dev/stdin");}if(Module["stdout"]){FS.createDevice("/dev","stdout",null,Module["stdout"]);}else {FS.symlink("/dev/tty","/dev/stdout");}if(Module["stderr"]){FS.createDevice("/dev","stderr",null,Module["stderr"]);}else {FS.symlink("/dev/tty1","/dev/stderr");}FS.open("/dev/stdin",0);FS.open("/dev/stdout",1);FS.open("/dev/stderr",1);},staticInit(){[44].forEach(code=>{FS.genericErrors[code]=new FS.ErrnoError(code);FS.genericErrors[code].stack="";});FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={MEMFS:MEMFS};},init(input,output,error){FS.init.initialized=true;Module["stdin"]=input||Module["stdin"];Module["stdout"]=output||Module["stdout"];Module["stderr"]=error||Module["stderr"];FS.createStandardStreams();},quit(){FS.init.initialized=false;for(var i=0;ithis.length-1||idx<0){return undefined}var chunkOffset=idx%this.chunkSize;var chunkNum=idx/this.chunkSize|0;return this.getter(chunkNum)[chunkOffset]}setDataGetter(getter){this.getter=getter;}cacheLength(){var xhr=new XMLHttpRequest;xhr.open("HEAD",url,false);xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);var datalength=Number(xhr.getResponseHeader("Content-length"));var header;var hasByteServing=(header=xhr.getResponseHeader("Accept-Ranges"))&&header==="bytes";var usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=(from,to)=>{if(from>to)throw new Error("invalid range ("+from+", "+to+") or no bytes requested!");if(to>datalength-1)throw new Error("only "+datalength+" bytes available! programmer error!");var xhr=new XMLHttpRequest;xhr.open("GET",url,false);if(datalength!==chunkSize)xhr.setRequestHeader("Range","bytes="+from+"-"+to);xhr.responseType="arraybuffer";if(xhr.overrideMimeType){xhr.overrideMimeType("text/plain; charset=x-user-defined");}xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);if(xhr.response!==undefined){return new Uint8Array(xhr.response||[])}return intArrayFromString(xhr.responseText||"",true)};var lazyArray=this;lazyArray.setDataGetter(chunkNum=>{var start=chunkNum*chunkSize;var end=(chunkNum+1)*chunkSize-1;end=Math.min(end,datalength-1);if(typeof lazyArray.chunks[chunkNum]=="undefined"){lazyArray.chunks[chunkNum]=doXHR(start,end);}if(typeof lazyArray.chunks[chunkNum]=="undefined")throw new Error("doXHR failed!");return lazyArray.chunks[chunkNum]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;out("LazyFiles on gzip forces download of the whole file when length is accessed");}this._length=datalength;this._chunkSize=chunkSize;this.lengthKnown=true;}get length(){if(!this.lengthKnown){this.cacheLength();}return this._length}get chunkSize(){if(!this.lengthKnown){this.cacheLength();}return this._chunkSize}}if(typeof XMLHttpRequest!="undefined"){if(!ENVIRONMENT_IS_WORKER)throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";var lazyArray=new LazyUint8Array;var properties={isDevice:false,contents:lazyArray};}else {var properties={isDevice:false,url:url};}var node=FS.createFile(parent,name,properties,canRead,canWrite);if(properties.contents){node.contents=properties.contents;}else if(properties.url){node.contents=null;node.url=properties.url;}Object.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};var keys=Object.keys(node.stream_ops);keys.forEach(key=>{var fn=node.stream_ops[key];stream_ops[key]=(...args)=>{FS.forceLoadFile(node);return fn(...args)};});function writeChunks(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i{FS.forceLoadFile(node);return writeChunks(stream,buffer,offset,length,position)};stream_ops.mmap=(stream,length,position,prot,flags)=>{FS.forceLoadFile(node);var ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}writeChunks(stream,HEAP8,ptr,length,position);return {ptr:ptr,allocated:true}};node.stream_ops=stream_ops;return node}};var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd();}else {var dirstream=SYSCALLS.getStreamFromFD(dirfd);dir=dirstream.path;}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return PATH.join2(dir,path)},doStat(func,path,buf){var stat=func(path);HEAP32[buf>>2]=stat.dev;HEAP32[buf+4>>2]=stat.mode;HEAPU32[buf+8>>2]=stat.nlink;HEAP32[buf+12>>2]=stat.uid;HEAP32[buf+16>>2]=stat.gid;HEAP32[buf+20>>2]=stat.rdev;tempI64=[stat.size>>>0,(tempDouble=stat.size,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+24>>2]=tempI64[0],HEAP32[buf+28>>2]=tempI64[1];HEAP32[buf+32>>2]=4096;HEAP32[buf+36>>2]=stat.blocks;var atime=stat.atime.getTime();var mtime=stat.mtime.getTime();var ctime=stat.ctime.getTime();tempI64=[Math.floor(atime/1e3)>>>0,(tempDouble=Math.floor(atime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+40>>2]=tempI64[0],HEAP32[buf+44>>2]=tempI64[1];HEAPU32[buf+48>>2]=atime%1e3*1e3;tempI64=[Math.floor(mtime/1e3)>>>0,(tempDouble=Math.floor(mtime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+56>>2]=tempI64[0],HEAP32[buf+60>>2]=tempI64[1];HEAPU32[buf+64>>2]=mtime%1e3*1e3;tempI64=[Math.floor(ctime/1e3)>>>0,(tempDouble=Math.floor(ctime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+72>>2]=tempI64[0],HEAP32[buf+76>>2]=tempI64[1];HEAPU32[buf+80>>2]=ctime%1e3*1e3;tempI64=[stat.ino>>>0,(tempDouble=stat.ino,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+88>>2]=tempI64[0],HEAP32[buf+92>>2]=tempI64[1];return 0},doMsync(addr,stream,len,flags,offset){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(flags&2){return 0}var buffer=HEAPU8.slice(addr,addr+len);FS.msync(stream,buffer,offset,len,flags);},getStreamFromFD(fd){var stream=FS.getStreamChecked(fd);return stream},varargs:undefined,getStr(ptr){var ret=UTF8ToString(ptr);return ret}};function ___syscall_chmod(path,mode){try{path=SYSCALLS.getStr(path);FS.chmod(path,mode);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return -e.errno}}function ___syscall_faccessat(dirfd,path,amode,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(amode&~7){return -28}var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node){return -44}var perms="";if(amode&4)perms+="r";if(amode&2)perms+="w";if(amode&1)perms+="x";if(perms&&FS.nodePermissions(node,perms)){return -2}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return -e.errno}}function ___syscall_fchmod(fd,mode){try{FS.fchmod(fd,mode);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return -e.errno}}function ___syscall_fchown32(fd,owner,group){try{FS.fchown(fd,owner,group);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return -e.errno}}function syscallGetVarargI(){var ret=HEAP32[+SYSCALLS.varargs>>2];SYSCALLS.varargs+=4;return ret}var syscallGetVarargP=syscallGetVarargI;function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=syscallGetVarargI();if(arg<0){return -28}while(FS.streams[arg]){arg++;}var newStream;newStream=FS.dupStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=syscallGetVarargI();stream.flags|=arg;return 0}case 12:{var arg=syscallGetVarargP();var offset=0;HEAP16[arg+offset>>1]=2;return 0}case 13:case 14:return 0}return -28}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return -e.errno}}function ___syscall_fstat64(fd,buf){try{var stream=SYSCALLS.getStreamFromFD(fd);return SYSCALLS.doStat(FS.stat,stream.path,buf)}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return -e.errno}}var convertI32PairToI53Checked=(lo,hi)=>hi+2097152>>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN;function ___syscall_ftruncate64(fd,length_low,length_high){var length=convertI32PairToI53Checked(length_low,length_high);try{if(isNaN(length))return 61;FS.ftruncate(fd,length);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return -e.errno}}var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);function ___syscall_getcwd(buf,size){try{if(size===0)return -28;var cwd=FS.cwd();var cwdLengthInBytes=lengthBytesUTF8(cwd)+1;if(sizeHEAPU32[ptr>>2]+HEAP32[ptr+4>>2]*4294967296;function ___syscall_utimensat(dirfd,path,times,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path,true);if(!times){var atime=Date.now();var mtime=atime;}else {var seconds=readI53FromI64(times);var nanoseconds=HEAP32[times+8>>2];atime=seconds*1e3+nanoseconds/(1e3*1e3);times+=16;seconds=readI53FromI64(times);nanoseconds=HEAP32[times+8>>2];mtime=seconds*1e3+nanoseconds/(1e3*1e3);}FS.utime(path,atime,mtime);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return -e.errno}}var isLeapYear=year=>year%4===0&&(year%100!==0||year%400===0);var MONTH_DAYS_LEAP_CUMULATIVE=[0,31,60,91,121,152,182,213,244,274,305,335];var MONTH_DAYS_REGULAR_CUMULATIVE=[0,31,59,90,120,151,181,212,243,273,304,334];var ydayFromDate=date=>{var leap=isLeapYear(date.getFullYear());var monthDaysCumulative=leap?MONTH_DAYS_LEAP_CUMULATIVE:MONTH_DAYS_REGULAR_CUMULATIVE;var yday=monthDaysCumulative[date.getMonth()]+date.getDate()-1;return yday};function __localtime_js(time_low,time_high,tmPtr){var time=convertI32PairToI53Checked(time_low,time_high);var date=new Date(time*1e3);HEAP32[tmPtr>>2]=date.getSeconds();HEAP32[tmPtr+4>>2]=date.getMinutes();HEAP32[tmPtr+8>>2]=date.getHours();HEAP32[tmPtr+12>>2]=date.getDate();HEAP32[tmPtr+16>>2]=date.getMonth();HEAP32[tmPtr+20>>2]=date.getFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getDay();var yday=ydayFromDate(date)|0;HEAP32[tmPtr+28>>2]=yday;HEAP32[tmPtr+36>>2]=-(date.getTimezoneOffset()*60);var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dst=(summerOffset!=winterOffset&&date.getTimezoneOffset()==Math.min(winterOffset,summerOffset))|0;HEAP32[tmPtr+32>>2]=dst;}function __mmap_js(len,prot,flags,fd,offset_low,offset_high,allocated,addr){var offset=convertI32PairToI53Checked(offset_low,offset_high);try{if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);var res=FS.mmap(stream,len,offset,prot,flags);var ptr=res.ptr;HEAP32[allocated>>2]=res.allocated;HEAPU32[addr>>2]=ptr;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return -e.errno}}function __munmap_js(addr,len,prot,flags,fd,offset_low,offset_high){var offset=convertI32PairToI53Checked(offset_low,offset_high);try{var stream=SYSCALLS.getStreamFromFD(fd);if(prot&2){SYSCALLS.doMsync(addr,stream,len,flags,offset);}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return -e.errno}}var __tzset_js=(timezone,daylight,std_name,dst_name)=>{var currentYear=(new Date).getFullYear();var winter=new Date(currentYear,0,1);var summer=new Date(currentYear,6,1);var winterOffset=winter.getTimezoneOffset();var summerOffset=summer.getTimezoneOffset();var stdTimezoneOffset=Math.max(winterOffset,summerOffset);HEAPU32[timezone>>2]=stdTimezoneOffset*60;HEAP32[daylight>>2]=Number(winterOffset!=summerOffset);var extractZone=date=>date.toLocaleTimeString(undefined,{hour12:false,timeZoneName:"short"}).split(" ")[1];var winterName=extractZone(winter);var summerName=extractZone(summer);if(summerOffsetDate.now();var _emscripten_get_now;_emscripten_get_now=()=>performance.now();var getHeapMax=()=>2147483648;var growMemory=size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}var alignUp=(x,multiple)=>x+(multiple-x%multiple)%multiple;for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignUp(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var ENV={};var getExecutableName=()=>thisProgram||"./this.program";var getEnvStrings=()=>{if(!getEnvStrings.strings){var lang=(typeof navigator=="object"&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8";var env={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:lang,_:getExecutableName()};for(var x in ENV){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x];}var strings=[];for(var x in env){strings.push(`${x}=${env[x]}`);}getEnvStrings.strings=strings;}return getEnvStrings.strings};var stringToAscii=(str,buffer)=>{for(var i=0;i{var bufSize=0;getEnvStrings().forEach((string,i)=>{var ptr=environ_buf+bufSize;HEAPU32[__environ+i*4>>2]=ptr;stringToAscii(string,ptr);bufSize+=string.length+1;});return 0};var _environ_sizes_get=(penviron_count,penviron_buf_size)=>{var strings=getEnvStrings();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;strings.forEach(string=>bufSize+=string.length+1);HEAPU32[penviron_buf_size>>2]=bufSize;return 0};function _fd_close(fd){try{var stream=SYSCALLS.getStreamFromFD(fd);FS.close(stream);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_fdstat_get(fd,pbuf){try{var rightsBase=0;var rightsInheriting=0;var flags=0;{var stream=SYSCALLS.getStreamFromFD(fd);var type=stream.tty?2:FS.isDir(stream.mode)?3:FS.isLink(stream.mode)?7:4;}HEAP8[pbuf]=type;HEAP16[pbuf+2>>1]=flags;tempI64=[rightsBase>>>0,(tempDouble=rightsBase,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[pbuf+8>>2]=tempI64[0],HEAP32[pbuf+12>>2]=tempI64[1];tempI64=[rightsInheriting>>>0,(tempDouble=rightsInheriting,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[pbuf+16>>2]=tempI64[0],HEAP32[pbuf+20>>2]=tempI64[1];return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doReadv=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return -1;ret+=curr;if(curr>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_seek(fd,offset_low,offset_high,whence,newOffset){var offset=convertI32PairToI53Checked(offset_low,offset_high);try{if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);tempI64=[stream.position>>>0,(tempDouble=stream.position,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[newOffset>>2]=tempI64[0],HEAP32[newOffset+4>>2]=tempI64[1];if(stream.getdents&&offset===0&&whence===0)stream.getdents=null;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_sync(fd){try{var stream=SYSCALLS.getStreamFromFD(fd);if(stream.stream_ops?.fsync){return stream.stream_ops.fsync(stream)}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doWritev=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return -1;ret+=curr;}return ret};function _fd_write(fd,iov,iovcnt,pnum){try{var stream=SYSCALLS.getStreamFromFD(fd);var num=doWritev(stream,iov,iovcnt);HEAPU32[pnum>>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var adapters_support=function(){const handleAsync=typeof Asyncify==="object"?Asyncify.handleAsync.bind(Asyncify):null;Module["handleAsync"]=handleAsync;const targets=new Map;Module["setCallback"]=(key,target)=>targets.set(key,target);Module["getCallback"]=key=>targets.get(key);Module["deleteCallback"]=key=>targets.delete(key);adapters_support=function(isAsync,key,...args){const receiver=targets.get(key);let methodName=null;const f=typeof receiver==="function"?receiver:receiver[methodName=UTF8ToString(args.shift())];if(isAsync){if(handleAsync){return handleAsync(()=>f.apply(receiver,args))}throw new Error("Synchronous WebAssembly cannot call async function")}const result=f.apply(receiver,args);if(typeof result?.then=="function"){console.error("unexpected Promise",f);throw new Error(`${methodName} unexpectedly returned a Promise`)}return result};};function _ipp(...args){return adapters_support(false,...args)}function _ipp_async(...args){return adapters_support(true,...args)}function _ippipppp(...args){return adapters_support(false,...args)}function _ippipppp_async(...args){return adapters_support(true,...args)}function _ippp(...args){return adapters_support(false,...args)}function _ippp_async(...args){return adapters_support(true,...args)}function _ipppi(...args){return adapters_support(false,...args)}function _ipppi_async(...args){return adapters_support(true,...args)}function _ipppiii(...args){return adapters_support(false,...args)}function _ipppiii_async(...args){return adapters_support(true,...args)}function _ipppiiip(...args){return adapters_support(false,...args)}function _ipppiiip_async(...args){return adapters_support(true,...args)}function _ipppip(...args){return adapters_support(false,...args)}function _ipppip_async(...args){return adapters_support(true,...args)}function _ipppj(...args){return adapters_support(false,...args)}function _ipppj_async(...args){return adapters_support(true,...args)}function _ipppp(...args){return adapters_support(false,...args)}function _ipppp_async(...args){return adapters_support(true,...args)}function _ippppi(...args){return adapters_support(false,...args)}function _ippppi_async(...args){return adapters_support(true,...args)}function _ippppij(...args){return adapters_support(false,...args)}function _ippppij_async(...args){return adapters_support(true,...args)}function _ippppip(...args){return adapters_support(false,...args)}function _ippppip_async(...args){return adapters_support(true,...args)}function _ipppppip(...args){return adapters_support(false,...args)}function _ipppppip_async(...args){return adapters_support(true,...args)}function _vppp(...args){return adapters_support(false,...args)}function _vppp_async(...args){return adapters_support(true,...args)}function _vpppip(...args){return adapters_support(false,...args)}function _vpppip_async(...args){return adapters_support(true,...args)}var runtimeKeepaliveCounter=0;var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){Module["onExit"]?.(code);ABORT=true;}quit_(code,new ExitStatus(code));};var exitJS=(status,implicit)=>{EXITSTATUS=status;_proc_exit(status);};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e);};var uleb128Encode=(n,target)=>{if(n<128){target.push(n);}else {target.push(n%128|128,n>>7);}};var sigToWasmTypes=sig=>{var typeNames={i:"i32",j:"i64",f:"f32",d:"f64",e:"externref",p:"i32"};var type={parameters:[],results:sig[0]=="v"?[]:[typeNames[sig[0]]]};for(var i=1;i{var sigRet=sig.slice(0,1);var sigParam=sig.slice(1);var typeCodes={i:127,p:127,j:126,f:125,d:124,e:111};target.push(96);uleb128Encode(sigParam.length,target);for(var i=0;i{if(typeof WebAssembly.Function=="function"){return new WebAssembly.Function(sigToWasmTypes(sig),func)}var typeSectionBody=[1];generateFuncType(sig,typeSectionBody);var bytes=[0,97,115,109,1,0,0,0,1];uleb128Encode(typeSectionBody.length,bytes);bytes.push(...typeSectionBody);bytes.push(2,7,1,1,101,1,102,0,0,7,5,1,1,102,0,0);var module=new WebAssembly.Module(new Uint8Array(bytes));var instance=new WebAssembly.Instance(module,{e:{f:func}});var wrappedFunc=instance.exports["f"];return wrappedFunc};var wasmTable;var getWasmTableEntry=funcPtr=>wasmTable.get(funcPtr);var updateTableMap=(offset,count)=>{if(functionsInTableMap){for(var i=offset;i{if(!functionsInTableMap){functionsInTableMap=new WeakMap;updateTableMap(0,wasmTable.length);}return functionsInTableMap.get(func)||0};var freeTableIndexes=[];var getEmptyTableSlot=()=>{if(freeTableIndexes.length){return freeTableIndexes.pop()}try{wasmTable.grow(1);}catch(err){if(!(err instanceof RangeError)){throw err}throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH."}return wasmTable.length-1};var setWasmTableEntry=(idx,func)=>wasmTable.set(idx,func);var addFunction=(func,sig)=>{var rtn=getFunctionAddress(func);if(rtn){return rtn}var ret=getEmptyTableSlot();try{setWasmTableEntry(ret,func);}catch(err){if(!(err instanceof TypeError)){throw err}var wrapped=convertJsFunctionToWasm(func,sig);setWasmTableEntry(ret,wrapped);}functionsInTableMap.set(func,ret);return ret};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{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};var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str);}return ret},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return (...args)=>ccall(ident,returnType,argTypes,args)};var getTempRet0=val=>__emscripten_tempret_get();var stringToUTF16=(str,outPtr,maxBytesToWrite)=>{maxBytesToWrite??=2147483647;if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite>1]=codeUnit;outPtr+=2;}HEAP16[outPtr>>1]=0;return outPtr-startPtr};var stringToUTF32=(str,outPtr,maxBytesToWrite)=>{maxBytesToWrite??=2147483647;if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i=55296&&codeUnit<=57343){var trailSurrogate=str.charCodeAt(++i);codeUnit=65536+((codeUnit&1023)<<10)|trailSurrogate&1023;}HEAP32[outPtr>>2]=codeUnit;outPtr+=4;if(outPtr+4>endPtr)break}HEAP32[outPtr>>2]=0;return outPtr-startPtr};var AsciiToString=ptr=>{var str="";while(1){var ch=HEAPU8[ptr++];if(!ch)return str;str+=String.fromCharCode(ch);}};var UTF16Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf-16le"):undefined;var UTF16ToString=(ptr,maxBytesToRead)=>{var endPtr=ptr;var idx=endPtr>>1;var maxIdx=idx+maxBytesToRead/2;while(!(idx>=maxIdx)&&HEAPU16[idx])++idx;endPtr=idx<<1;if(endPtr-ptr>32&&UTF16Decoder)return UTF16Decoder.decode(HEAPU8.subarray(ptr,endPtr));var str="";for(var i=0;!(i>=maxBytesToRead/2);++i){var codeUnit=HEAP16[ptr+i*2>>1];if(codeUnit==0)break;str+=String.fromCharCode(codeUnit);}return str};var UTF32ToString=(ptr,maxBytesToRead)=>{var i=0;var str="";while(!(i>=maxBytesToRead/4)){var utf32=HEAP32[ptr+i*4>>2];if(utf32==0)break;++i;if(utf32>=65536){var ch=utf32-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023);}else {str+=String.fromCharCode(utf32);}}return str};function intArrayToString(array){var ret=[];for(var i=0;i255){chr&=255;}ret.push(String.fromCharCode(chr));}return ret.join("")}FS.createPreloadedFile=FS_createPreloadedFile;FS.staticInit();adapters_support();var wasmImports={a:___assert_fail,Y:___syscall_chmod,$:___syscall_faccessat,Z:___syscall_fchmod,X:___syscall_fchown32,b:___syscall_fcntl64,W:___syscall_fstat64,y:___syscall_ftruncate64,Q:___syscall_getcwd,U:___syscall_lstat64,N:___syscall_mkdirat,T:___syscall_newfstatat,L:___syscall_openat,J:___syscall_readlinkat,I:___syscall_rmdir,V:___syscall_stat64,G:___syscall_unlinkat,F:___syscall_utimensat,w:__localtime_js,u:__mmap_js,v:__munmap_js,M:__tzset_js,n:_emscripten_date_now,m:_emscripten_get_now,D:_emscripten_resize_heap,O:_environ_get,P:_environ_sizes_get,o:_fd_close,E:_fd_fdstat_get,K:_fd_read,x:_fd_seek,S:_fd_sync,H:_fd_write,s:_ipp,t:_ipp_async,fa:_ippipppp,ia:_ippipppp_async,i:_ippp,j:_ippp_async,c:_ipppi,d:_ipppi_async,ca:_ipppiii,da:_ipppiii_async,ea:_ipppiiip,ga:_ipppiiip_async,g:_ipppip,h:_ipppip_async,z:_ipppj,A:_ipppj_async,e:_ipppp,f:_ipppp_async,aa:_ippppi,ba:_ippppi_async,B:_ippppij,C:_ippppij_async,p:_ippppip,q:_ippppip_async,ha:_ipppppip,r:_ipppppip_async,k:_vppp,l:_vppp_async,R:_vpppip,_:_vpppip_async};var wasmExports=createWasm();Module["_sqlite3_status64"]=(a0,a1,a2,a3)=>(Module["_sqlite3_status64"]=wasmExports["la"])(a0,a1,a2,a3);Module["_sqlite3_status"]=(a0,a1,a2,a3)=>(Module["_sqlite3_status"]=wasmExports["ma"])(a0,a1,a2,a3);Module["_sqlite3_db_status"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_db_status"]=wasmExports["na"])(a0,a1,a2,a3,a4);Module["_sqlite3_msize"]=a0=>(Module["_sqlite3_msize"]=wasmExports["oa"])(a0);Module["_sqlite3_vfs_find"]=a0=>(Module["_sqlite3_vfs_find"]=wasmExports["pa"])(a0);Module["_sqlite3_vfs_register"]=(a0,a1)=>(Module["_sqlite3_vfs_register"]=wasmExports["qa"])(a0,a1);Module["_sqlite3_vfs_unregister"]=a0=>(Module["_sqlite3_vfs_unregister"]=wasmExports["ra"])(a0);Module["_sqlite3_release_memory"]=a0=>(Module["_sqlite3_release_memory"]=wasmExports["sa"])(a0);Module["_sqlite3_soft_heap_limit64"]=(a0,a1)=>(Module["_sqlite3_soft_heap_limit64"]=wasmExports["ta"])(a0,a1);Module["_sqlite3_memory_used"]=()=>(Module["_sqlite3_memory_used"]=wasmExports["ua"])();Module["_sqlite3_hard_heap_limit64"]=(a0,a1)=>(Module["_sqlite3_hard_heap_limit64"]=wasmExports["va"])(a0,a1);Module["_sqlite3_memory_highwater"]=a0=>(Module["_sqlite3_memory_highwater"]=wasmExports["wa"])(a0);Module["_sqlite3_malloc"]=a0=>(Module["_sqlite3_malloc"]=wasmExports["xa"])(a0);Module["_sqlite3_malloc64"]=(a0,a1)=>(Module["_sqlite3_malloc64"]=wasmExports["ya"])(a0,a1);Module["_sqlite3_free"]=a0=>(Module["_sqlite3_free"]=wasmExports["za"])(a0);Module["_sqlite3_realloc"]=(a0,a1)=>(Module["_sqlite3_realloc"]=wasmExports["Aa"])(a0,a1);Module["_sqlite3_realloc64"]=(a0,a1,a2)=>(Module["_sqlite3_realloc64"]=wasmExports["Ba"])(a0,a1,a2);Module["_sqlite3_str_vappendf"]=(a0,a1,a2)=>(Module["_sqlite3_str_vappendf"]=wasmExports["Ca"])(a0,a1,a2);Module["_sqlite3_str_append"]=(a0,a1,a2)=>(Module["_sqlite3_str_append"]=wasmExports["Da"])(a0,a1,a2);Module["_sqlite3_str_appendchar"]=(a0,a1,a2)=>(Module["_sqlite3_str_appendchar"]=wasmExports["Ea"])(a0,a1,a2);Module["_sqlite3_str_appendall"]=(a0,a1)=>(Module["_sqlite3_str_appendall"]=wasmExports["Fa"])(a0,a1);Module["_sqlite3_str_appendf"]=(a0,a1,a2)=>(Module["_sqlite3_str_appendf"]=wasmExports["Ga"])(a0,a1,a2);Module["_sqlite3_str_finish"]=a0=>(Module["_sqlite3_str_finish"]=wasmExports["Ha"])(a0);Module["_sqlite3_str_errcode"]=a0=>(Module["_sqlite3_str_errcode"]=wasmExports["Ia"])(a0);Module["_sqlite3_str_length"]=a0=>(Module["_sqlite3_str_length"]=wasmExports["Ja"])(a0);Module["_sqlite3_str_value"]=a0=>(Module["_sqlite3_str_value"]=wasmExports["Ka"])(a0);Module["_sqlite3_str_reset"]=a0=>(Module["_sqlite3_str_reset"]=wasmExports["La"])(a0);Module["_sqlite3_str_new"]=a0=>(Module["_sqlite3_str_new"]=wasmExports["Ma"])(a0);Module["_sqlite3_vmprintf"]=(a0,a1)=>(Module["_sqlite3_vmprintf"]=wasmExports["Na"])(a0,a1);Module["_sqlite3_mprintf"]=(a0,a1)=>(Module["_sqlite3_mprintf"]=wasmExports["Oa"])(a0,a1);Module["_sqlite3_vsnprintf"]=(a0,a1,a2,a3)=>(Module["_sqlite3_vsnprintf"]=wasmExports["Pa"])(a0,a1,a2,a3);Module["_sqlite3_snprintf"]=(a0,a1,a2,a3)=>(Module["_sqlite3_snprintf"]=wasmExports["Qa"])(a0,a1,a2,a3);Module["_sqlite3_log"]=(a0,a1,a2)=>(Module["_sqlite3_log"]=wasmExports["Ra"])(a0,a1,a2);Module["_sqlite3_randomness"]=(a0,a1)=>(Module["_sqlite3_randomness"]=wasmExports["Sa"])(a0,a1);Module["_sqlite3_stricmp"]=(a0,a1)=>(Module["_sqlite3_stricmp"]=wasmExports["Ta"])(a0,a1);Module["_sqlite3_strnicmp"]=(a0,a1,a2)=>(Module["_sqlite3_strnicmp"]=wasmExports["Ua"])(a0,a1,a2);Module["_sqlite3_os_init"]=()=>(Module["_sqlite3_os_init"]=wasmExports["Va"])();Module["_sqlite3_os_end"]=()=>(Module["_sqlite3_os_end"]=wasmExports["Wa"])();Module["_sqlite3_serialize"]=(a0,a1,a2,a3)=>(Module["_sqlite3_serialize"]=wasmExports["Xa"])(a0,a1,a2,a3);Module["_sqlite3_prepare_v2"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_prepare_v2"]=wasmExports["Ya"])(a0,a1,a2,a3,a4);Module["_sqlite3_step"]=a0=>(Module["_sqlite3_step"]=wasmExports["Za"])(a0);Module["_sqlite3_column_int64"]=(a0,a1)=>(Module["_sqlite3_column_int64"]=wasmExports["_a"])(a0,a1);Module["_sqlite3_reset"]=a0=>(Module["_sqlite3_reset"]=wasmExports["$a"])(a0);Module["_sqlite3_exec"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_exec"]=wasmExports["ab"])(a0,a1,a2,a3,a4);Module["_sqlite3_column_int"]=(a0,a1)=>(Module["_sqlite3_column_int"]=wasmExports["bb"])(a0,a1);Module["_sqlite3_finalize"]=a0=>(Module["_sqlite3_finalize"]=wasmExports["cb"])(a0);Module["_sqlite3_deserialize"]=(a0,a1,a2,a3,a4,a5,a6,a7)=>(Module["_sqlite3_deserialize"]=wasmExports["db"])(a0,a1,a2,a3,a4,a5,a6,a7);Module["_sqlite3_database_file_object"]=a0=>(Module["_sqlite3_database_file_object"]=wasmExports["eb"])(a0);Module["_sqlite3_backup_init"]=(a0,a1,a2,a3)=>(Module["_sqlite3_backup_init"]=wasmExports["fb"])(a0,a1,a2,a3);Module["_sqlite3_backup_step"]=(a0,a1)=>(Module["_sqlite3_backup_step"]=wasmExports["gb"])(a0,a1);Module["_sqlite3_backup_finish"]=a0=>(Module["_sqlite3_backup_finish"]=wasmExports["hb"])(a0);Module["_sqlite3_backup_remaining"]=a0=>(Module["_sqlite3_backup_remaining"]=wasmExports["ib"])(a0);Module["_sqlite3_backup_pagecount"]=a0=>(Module["_sqlite3_backup_pagecount"]=wasmExports["jb"])(a0);Module["_sqlite3_clear_bindings"]=a0=>(Module["_sqlite3_clear_bindings"]=wasmExports["kb"])(a0);Module["_sqlite3_value_blob"]=a0=>(Module["_sqlite3_value_blob"]=wasmExports["lb"])(a0);Module["_sqlite3_value_text"]=a0=>(Module["_sqlite3_value_text"]=wasmExports["mb"])(a0);Module["_sqlite3_value_bytes"]=a0=>(Module["_sqlite3_value_bytes"]=wasmExports["nb"])(a0);Module["_sqlite3_value_bytes16"]=a0=>(Module["_sqlite3_value_bytes16"]=wasmExports["ob"])(a0);Module["_sqlite3_value_double"]=a0=>(Module["_sqlite3_value_double"]=wasmExports["pb"])(a0);Module["_sqlite3_value_int"]=a0=>(Module["_sqlite3_value_int"]=wasmExports["qb"])(a0);Module["_sqlite3_value_int64"]=a0=>(Module["_sqlite3_value_int64"]=wasmExports["rb"])(a0);Module["_sqlite3_value_subtype"]=a0=>(Module["_sqlite3_value_subtype"]=wasmExports["sb"])(a0);Module["_sqlite3_value_pointer"]=(a0,a1)=>(Module["_sqlite3_value_pointer"]=wasmExports["tb"])(a0,a1);Module["_sqlite3_value_text16"]=a0=>(Module["_sqlite3_value_text16"]=wasmExports["ub"])(a0);Module["_sqlite3_value_text16be"]=a0=>(Module["_sqlite3_value_text16be"]=wasmExports["vb"])(a0);Module["_sqlite3_value_text16le"]=a0=>(Module["_sqlite3_value_text16le"]=wasmExports["wb"])(a0);Module["_sqlite3_value_type"]=a0=>(Module["_sqlite3_value_type"]=wasmExports["xb"])(a0);Module["_sqlite3_value_encoding"]=a0=>(Module["_sqlite3_value_encoding"]=wasmExports["yb"])(a0);Module["_sqlite3_value_nochange"]=a0=>(Module["_sqlite3_value_nochange"]=wasmExports["zb"])(a0);Module["_sqlite3_value_frombind"]=a0=>(Module["_sqlite3_value_frombind"]=wasmExports["Ab"])(a0);Module["_sqlite3_value_dup"]=a0=>(Module["_sqlite3_value_dup"]=wasmExports["Bb"])(a0);Module["_sqlite3_value_free"]=a0=>(Module["_sqlite3_value_free"]=wasmExports["Cb"])(a0);Module["_sqlite3_result_blob"]=(a0,a1,a2,a3)=>(Module["_sqlite3_result_blob"]=wasmExports["Db"])(a0,a1,a2,a3);Module["_sqlite3_result_blob64"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_result_blob64"]=wasmExports["Eb"])(a0,a1,a2,a3,a4);Module["_sqlite3_result_double"]=(a0,a1)=>(Module["_sqlite3_result_double"]=wasmExports["Fb"])(a0,a1);Module["_sqlite3_result_error"]=(a0,a1,a2)=>(Module["_sqlite3_result_error"]=wasmExports["Gb"])(a0,a1,a2);Module["_sqlite3_result_error16"]=(a0,a1,a2)=>(Module["_sqlite3_result_error16"]=wasmExports["Hb"])(a0,a1,a2);Module["_sqlite3_result_int"]=(a0,a1)=>(Module["_sqlite3_result_int"]=wasmExports["Ib"])(a0,a1);Module["_sqlite3_result_int64"]=(a0,a1,a2)=>(Module["_sqlite3_result_int64"]=wasmExports["Jb"])(a0,a1,a2);Module["_sqlite3_result_null"]=a0=>(Module["_sqlite3_result_null"]=wasmExports["Kb"])(a0);Module["_sqlite3_result_pointer"]=(a0,a1,a2,a3)=>(Module["_sqlite3_result_pointer"]=wasmExports["Lb"])(a0,a1,a2,a3);Module["_sqlite3_result_subtype"]=(a0,a1)=>(Module["_sqlite3_result_subtype"]=wasmExports["Mb"])(a0,a1);Module["_sqlite3_result_text"]=(a0,a1,a2,a3)=>(Module["_sqlite3_result_text"]=wasmExports["Nb"])(a0,a1,a2,a3);Module["_sqlite3_result_text64"]=(a0,a1,a2,a3,a4,a5)=>(Module["_sqlite3_result_text64"]=wasmExports["Ob"])(a0,a1,a2,a3,a4,a5);Module["_sqlite3_result_text16"]=(a0,a1,a2,a3)=>(Module["_sqlite3_result_text16"]=wasmExports["Pb"])(a0,a1,a2,a3);Module["_sqlite3_result_text16be"]=(a0,a1,a2,a3)=>(Module["_sqlite3_result_text16be"]=wasmExports["Qb"])(a0,a1,a2,a3);Module["_sqlite3_result_text16le"]=(a0,a1,a2,a3)=>(Module["_sqlite3_result_text16le"]=wasmExports["Rb"])(a0,a1,a2,a3);Module["_sqlite3_result_value"]=(a0,a1)=>(Module["_sqlite3_result_value"]=wasmExports["Sb"])(a0,a1);Module["_sqlite3_result_error_toobig"]=a0=>(Module["_sqlite3_result_error_toobig"]=wasmExports["Tb"])(a0);Module["_sqlite3_result_zeroblob"]=(a0,a1)=>(Module["_sqlite3_result_zeroblob"]=wasmExports["Ub"])(a0,a1);Module["_sqlite3_result_zeroblob64"]=(a0,a1,a2)=>(Module["_sqlite3_result_zeroblob64"]=wasmExports["Vb"])(a0,a1,a2);Module["_sqlite3_result_error_code"]=(a0,a1)=>(Module["_sqlite3_result_error_code"]=wasmExports["Wb"])(a0,a1);Module["_sqlite3_result_error_nomem"]=a0=>(Module["_sqlite3_result_error_nomem"]=wasmExports["Xb"])(a0);Module["_sqlite3_user_data"]=a0=>(Module["_sqlite3_user_data"]=wasmExports["Yb"])(a0);Module["_sqlite3_context_db_handle"]=a0=>(Module["_sqlite3_context_db_handle"]=wasmExports["Zb"])(a0);Module["_sqlite3_vtab_nochange"]=a0=>(Module["_sqlite3_vtab_nochange"]=wasmExports["_b"])(a0);Module["_sqlite3_vtab_in_first"]=(a0,a1)=>(Module["_sqlite3_vtab_in_first"]=wasmExports["$b"])(a0,a1);Module["_sqlite3_vtab_in_next"]=(a0,a1)=>(Module["_sqlite3_vtab_in_next"]=wasmExports["ac"])(a0,a1);Module["_sqlite3_aggregate_context"]=(a0,a1)=>(Module["_sqlite3_aggregate_context"]=wasmExports["bc"])(a0,a1);Module["_sqlite3_get_auxdata"]=(a0,a1)=>(Module["_sqlite3_get_auxdata"]=wasmExports["cc"])(a0,a1);Module["_sqlite3_set_auxdata"]=(a0,a1,a2,a3)=>(Module["_sqlite3_set_auxdata"]=wasmExports["dc"])(a0,a1,a2,a3);Module["_sqlite3_column_count"]=a0=>(Module["_sqlite3_column_count"]=wasmExports["ec"])(a0);Module["_sqlite3_data_count"]=a0=>(Module["_sqlite3_data_count"]=wasmExports["fc"])(a0);Module["_sqlite3_column_blob"]=(a0,a1)=>(Module["_sqlite3_column_blob"]=wasmExports["gc"])(a0,a1);Module["_sqlite3_column_bytes"]=(a0,a1)=>(Module["_sqlite3_column_bytes"]=wasmExports["hc"])(a0,a1);Module["_sqlite3_column_bytes16"]=(a0,a1)=>(Module["_sqlite3_column_bytes16"]=wasmExports["ic"])(a0,a1);Module["_sqlite3_column_double"]=(a0,a1)=>(Module["_sqlite3_column_double"]=wasmExports["jc"])(a0,a1);Module["_sqlite3_column_text"]=(a0,a1)=>(Module["_sqlite3_column_text"]=wasmExports["kc"])(a0,a1);Module["_sqlite3_column_value"]=(a0,a1)=>(Module["_sqlite3_column_value"]=wasmExports["lc"])(a0,a1);Module["_sqlite3_column_text16"]=(a0,a1)=>(Module["_sqlite3_column_text16"]=wasmExports["mc"])(a0,a1);Module["_sqlite3_column_type"]=(a0,a1)=>(Module["_sqlite3_column_type"]=wasmExports["nc"])(a0,a1);Module["_sqlite3_column_name"]=(a0,a1)=>(Module["_sqlite3_column_name"]=wasmExports["oc"])(a0,a1);Module["_sqlite3_column_name16"]=(a0,a1)=>(Module["_sqlite3_column_name16"]=wasmExports["pc"])(a0,a1);Module["_sqlite3_bind_blob"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_bind_blob"]=wasmExports["qc"])(a0,a1,a2,a3,a4);Module["_sqlite3_bind_blob64"]=(a0,a1,a2,a3,a4,a5)=>(Module["_sqlite3_bind_blob64"]=wasmExports["rc"])(a0,a1,a2,a3,a4,a5);Module["_sqlite3_bind_double"]=(a0,a1,a2)=>(Module["_sqlite3_bind_double"]=wasmExports["sc"])(a0,a1,a2);Module["_sqlite3_bind_int"]=(a0,a1,a2)=>(Module["_sqlite3_bind_int"]=wasmExports["tc"])(a0,a1,a2);Module["_sqlite3_bind_int64"]=(a0,a1,a2,a3)=>(Module["_sqlite3_bind_int64"]=wasmExports["uc"])(a0,a1,a2,a3);Module["_sqlite3_bind_null"]=(a0,a1)=>(Module["_sqlite3_bind_null"]=wasmExports["vc"])(a0,a1);Module["_sqlite3_bind_pointer"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_bind_pointer"]=wasmExports["wc"])(a0,a1,a2,a3,a4);Module["_sqlite3_bind_text"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_bind_text"]=wasmExports["xc"])(a0,a1,a2,a3,a4);Module["_sqlite3_bind_text64"]=(a0,a1,a2,a3,a4,a5,a6)=>(Module["_sqlite3_bind_text64"]=wasmExports["yc"])(a0,a1,a2,a3,a4,a5,a6);Module["_sqlite3_bind_text16"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_bind_text16"]=wasmExports["zc"])(a0,a1,a2,a3,a4);Module["_sqlite3_bind_value"]=(a0,a1,a2)=>(Module["_sqlite3_bind_value"]=wasmExports["Ac"])(a0,a1,a2);Module["_sqlite3_bind_zeroblob"]=(a0,a1,a2)=>(Module["_sqlite3_bind_zeroblob"]=wasmExports["Bc"])(a0,a1,a2);Module["_sqlite3_bind_zeroblob64"]=(a0,a1,a2,a3)=>(Module["_sqlite3_bind_zeroblob64"]=wasmExports["Cc"])(a0,a1,a2,a3);Module["_sqlite3_bind_parameter_count"]=a0=>(Module["_sqlite3_bind_parameter_count"]=wasmExports["Dc"])(a0);Module["_sqlite3_bind_parameter_name"]=(a0,a1)=>(Module["_sqlite3_bind_parameter_name"]=wasmExports["Ec"])(a0,a1);Module["_sqlite3_bind_parameter_index"]=(a0,a1)=>(Module["_sqlite3_bind_parameter_index"]=wasmExports["Fc"])(a0,a1);Module["_sqlite3_db_handle"]=a0=>(Module["_sqlite3_db_handle"]=wasmExports["Gc"])(a0);Module["_sqlite3_stmt_readonly"]=a0=>(Module["_sqlite3_stmt_readonly"]=wasmExports["Hc"])(a0);Module["_sqlite3_stmt_isexplain"]=a0=>(Module["_sqlite3_stmt_isexplain"]=wasmExports["Ic"])(a0);Module["_sqlite3_stmt_explain"]=(a0,a1)=>(Module["_sqlite3_stmt_explain"]=wasmExports["Jc"])(a0,a1);Module["_sqlite3_stmt_busy"]=a0=>(Module["_sqlite3_stmt_busy"]=wasmExports["Kc"])(a0);Module["_sqlite3_next_stmt"]=(a0,a1)=>(Module["_sqlite3_next_stmt"]=wasmExports["Lc"])(a0,a1);Module["_sqlite3_stmt_status"]=(a0,a1,a2)=>(Module["_sqlite3_stmt_status"]=wasmExports["Mc"])(a0,a1,a2);Module["_sqlite3_sql"]=a0=>(Module["_sqlite3_sql"]=wasmExports["Nc"])(a0);Module["_sqlite3_expanded_sql"]=a0=>(Module["_sqlite3_expanded_sql"]=wasmExports["Oc"])(a0);Module["_sqlite3_value_numeric_type"]=a0=>(Module["_sqlite3_value_numeric_type"]=wasmExports["Pc"])(a0);Module["_sqlite3_blob_open"]=(a0,a1,a2,a3,a4,a5,a6,a7)=>(Module["_sqlite3_blob_open"]=wasmExports["Qc"])(a0,a1,a2,a3,a4,a5,a6,a7);Module["_sqlite3_blob_close"]=a0=>(Module["_sqlite3_blob_close"]=wasmExports["Rc"])(a0);Module["_sqlite3_blob_read"]=(a0,a1,a2,a3)=>(Module["_sqlite3_blob_read"]=wasmExports["Sc"])(a0,a1,a2,a3);Module["_sqlite3_blob_write"]=(a0,a1,a2,a3)=>(Module["_sqlite3_blob_write"]=wasmExports["Tc"])(a0,a1,a2,a3);Module["_sqlite3_blob_bytes"]=a0=>(Module["_sqlite3_blob_bytes"]=wasmExports["Uc"])(a0);Module["_sqlite3_blob_reopen"]=(a0,a1,a2)=>(Module["_sqlite3_blob_reopen"]=wasmExports["Vc"])(a0,a1,a2);Module["_sqlite3_set_authorizer"]=(a0,a1,a2)=>(Module["_sqlite3_set_authorizer"]=wasmExports["Wc"])(a0,a1,a2);Module["_sqlite3_strglob"]=(a0,a1)=>(Module["_sqlite3_strglob"]=wasmExports["Xc"])(a0,a1);Module["_sqlite3_strlike"]=(a0,a1,a2)=>(Module["_sqlite3_strlike"]=wasmExports["Yc"])(a0,a1,a2);Module["_sqlite3_errmsg"]=a0=>(Module["_sqlite3_errmsg"]=wasmExports["Zc"])(a0);Module["_sqlite3_auto_extension"]=a0=>(Module["_sqlite3_auto_extension"]=wasmExports["_c"])(a0);Module["_sqlite3_cancel_auto_extension"]=a0=>(Module["_sqlite3_cancel_auto_extension"]=wasmExports["$c"])(a0);Module["_sqlite3_reset_auto_extension"]=()=>(Module["_sqlite3_reset_auto_extension"]=wasmExports["ad"])();Module["_sqlite3_prepare"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_prepare"]=wasmExports["bd"])(a0,a1,a2,a3,a4);Module["_sqlite3_prepare_v3"]=(a0,a1,a2,a3,a4,a5)=>(Module["_sqlite3_prepare_v3"]=wasmExports["cd"])(a0,a1,a2,a3,a4,a5);Module["_sqlite3_prepare16"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_prepare16"]=wasmExports["dd"])(a0,a1,a2,a3,a4);Module["_sqlite3_prepare16_v2"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_prepare16_v2"]=wasmExports["ed"])(a0,a1,a2,a3,a4);Module["_sqlite3_prepare16_v3"]=(a0,a1,a2,a3,a4,a5)=>(Module["_sqlite3_prepare16_v3"]=wasmExports["fd"])(a0,a1,a2,a3,a4,a5);Module["_sqlite3_get_table"]=(a0,a1,a2,a3,a4,a5)=>(Module["_sqlite3_get_table"]=wasmExports["gd"])(a0,a1,a2,a3,a4,a5);Module["_sqlite3_free_table"]=a0=>(Module["_sqlite3_free_table"]=wasmExports["hd"])(a0);Module["_sqlite3_create_module"]=(a0,a1,a2,a3)=>(Module["_sqlite3_create_module"]=wasmExports["id"])(a0,a1,a2,a3);Module["_sqlite3_create_module_v2"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_create_module_v2"]=wasmExports["jd"])(a0,a1,a2,a3,a4);Module["_sqlite3_drop_modules"]=(a0,a1)=>(Module["_sqlite3_drop_modules"]=wasmExports["kd"])(a0,a1);Module["_sqlite3_declare_vtab"]=(a0,a1)=>(Module["_sqlite3_declare_vtab"]=wasmExports["ld"])(a0,a1);Module["_sqlite3_vtab_on_conflict"]=a0=>(Module["_sqlite3_vtab_on_conflict"]=wasmExports["md"])(a0);Module["_sqlite3_vtab_config"]=(a0,a1,a2)=>(Module["_sqlite3_vtab_config"]=wasmExports["nd"])(a0,a1,a2);Module["_sqlite3_vtab_collation"]=(a0,a1)=>(Module["_sqlite3_vtab_collation"]=wasmExports["od"])(a0,a1);Module["_sqlite3_vtab_in"]=(a0,a1,a2)=>(Module["_sqlite3_vtab_in"]=wasmExports["pd"])(a0,a1,a2);Module["_sqlite3_vtab_rhs_value"]=(a0,a1,a2)=>(Module["_sqlite3_vtab_rhs_value"]=wasmExports["qd"])(a0,a1,a2);Module["_sqlite3_vtab_distinct"]=a0=>(Module["_sqlite3_vtab_distinct"]=wasmExports["rd"])(a0);Module["_sqlite3_keyword_name"]=(a0,a1,a2)=>(Module["_sqlite3_keyword_name"]=wasmExports["sd"])(a0,a1,a2);Module["_sqlite3_keyword_count"]=()=>(Module["_sqlite3_keyword_count"]=wasmExports["td"])();Module["_sqlite3_keyword_check"]=(a0,a1)=>(Module["_sqlite3_keyword_check"]=wasmExports["ud"])(a0,a1);Module["_sqlite3_complete"]=a0=>(Module["_sqlite3_complete"]=wasmExports["vd"])(a0);Module["_sqlite3_complete16"]=a0=>(Module["_sqlite3_complete16"]=wasmExports["wd"])(a0);Module["_sqlite3_libversion"]=()=>(Module["_sqlite3_libversion"]=wasmExports["xd"])();Module["_sqlite3_libversion_number"]=()=>(Module["_sqlite3_libversion_number"]=wasmExports["yd"])();Module["_sqlite3_threadsafe"]=()=>(Module["_sqlite3_threadsafe"]=wasmExports["zd"])();Module["_sqlite3_initialize"]=()=>(Module["_sqlite3_initialize"]=wasmExports["Ad"])();Module["_sqlite3_shutdown"]=()=>(Module["_sqlite3_shutdown"]=wasmExports["Bd"])();Module["_sqlite3_config"]=(a0,a1)=>(Module["_sqlite3_config"]=wasmExports["Cd"])(a0,a1);Module["_sqlite3_db_mutex"]=a0=>(Module["_sqlite3_db_mutex"]=wasmExports["Dd"])(a0);Module["_sqlite3_db_release_memory"]=a0=>(Module["_sqlite3_db_release_memory"]=wasmExports["Ed"])(a0);Module["_sqlite3_db_cacheflush"]=a0=>(Module["_sqlite3_db_cacheflush"]=wasmExports["Fd"])(a0);Module["_sqlite3_db_config"]=(a0,a1,a2)=>(Module["_sqlite3_db_config"]=wasmExports["Gd"])(a0,a1,a2);Module["_sqlite3_last_insert_rowid"]=a0=>(Module["_sqlite3_last_insert_rowid"]=wasmExports["Hd"])(a0);Module["_sqlite3_set_last_insert_rowid"]=(a0,a1,a2)=>(Module["_sqlite3_set_last_insert_rowid"]=wasmExports["Id"])(a0,a1,a2);Module["_sqlite3_changes64"]=a0=>(Module["_sqlite3_changes64"]=wasmExports["Jd"])(a0);Module["_sqlite3_changes"]=a0=>(Module["_sqlite3_changes"]=wasmExports["Kd"])(a0);Module["_sqlite3_total_changes64"]=a0=>(Module["_sqlite3_total_changes64"]=wasmExports["Ld"])(a0);Module["_sqlite3_total_changes"]=a0=>(Module["_sqlite3_total_changes"]=wasmExports["Md"])(a0);Module["_sqlite3_txn_state"]=(a0,a1)=>(Module["_sqlite3_txn_state"]=wasmExports["Nd"])(a0,a1);Module["_sqlite3_close"]=a0=>(Module["_sqlite3_close"]=wasmExports["Od"])(a0);Module["_sqlite3_close_v2"]=a0=>(Module["_sqlite3_close_v2"]=wasmExports["Pd"])(a0);Module["_sqlite3_busy_handler"]=(a0,a1,a2)=>(Module["_sqlite3_busy_handler"]=wasmExports["Qd"])(a0,a1,a2);Module["_sqlite3_progress_handler"]=(a0,a1,a2,a3)=>(Module["_sqlite3_progress_handler"]=wasmExports["Rd"])(a0,a1,a2,a3);Module["_sqlite3_busy_timeout"]=(a0,a1)=>(Module["_sqlite3_busy_timeout"]=wasmExports["Sd"])(a0,a1);Module["_sqlite3_interrupt"]=a0=>(Module["_sqlite3_interrupt"]=wasmExports["Td"])(a0);Module["_sqlite3_is_interrupted"]=a0=>(Module["_sqlite3_is_interrupted"]=wasmExports["Ud"])(a0);Module["_sqlite3_create_function"]=(a0,a1,a2,a3,a4,a5,a6,a7)=>(Module["_sqlite3_create_function"]=wasmExports["Vd"])(a0,a1,a2,a3,a4,a5,a6,a7);Module["_sqlite3_create_function_v2"]=(a0,a1,a2,a3,a4,a5,a6,a7,a8)=>(Module["_sqlite3_create_function_v2"]=wasmExports["Wd"])(a0,a1,a2,a3,a4,a5,a6,a7,a8);Module["_sqlite3_create_window_function"]=(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9)=>(Module["_sqlite3_create_window_function"]=wasmExports["Xd"])(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9);Module["_sqlite3_create_function16"]=(a0,a1,a2,a3,a4,a5,a6,a7)=>(Module["_sqlite3_create_function16"]=wasmExports["Yd"])(a0,a1,a2,a3,a4,a5,a6,a7);Module["_sqlite3_overload_function"]=(a0,a1,a2)=>(Module["_sqlite3_overload_function"]=wasmExports["Zd"])(a0,a1,a2);Module["_sqlite3_trace_v2"]=(a0,a1,a2,a3)=>(Module["_sqlite3_trace_v2"]=wasmExports["_d"])(a0,a1,a2,a3);Module["_sqlite3_commit_hook"]=(a0,a1,a2)=>(Module["_sqlite3_commit_hook"]=wasmExports["$d"])(a0,a1,a2);Module["_sqlite3_update_hook"]=(a0,a1,a2)=>(Module["_sqlite3_update_hook"]=wasmExports["ae"])(a0,a1,a2);Module["_sqlite3_rollback_hook"]=(a0,a1,a2)=>(Module["_sqlite3_rollback_hook"]=wasmExports["be"])(a0,a1,a2);Module["_sqlite3_autovacuum_pages"]=(a0,a1,a2,a3)=>(Module["_sqlite3_autovacuum_pages"]=wasmExports["ce"])(a0,a1,a2,a3);Module["_sqlite3_wal_autocheckpoint"]=(a0,a1)=>(Module["_sqlite3_wal_autocheckpoint"]=wasmExports["de"])(a0,a1);Module["_sqlite3_wal_hook"]=(a0,a1,a2)=>(Module["_sqlite3_wal_hook"]=wasmExports["ee"])(a0,a1,a2);Module["_sqlite3_wal_checkpoint_v2"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_wal_checkpoint_v2"]=wasmExports["fe"])(a0,a1,a2,a3,a4);Module["_sqlite3_wal_checkpoint"]=(a0,a1)=>(Module["_sqlite3_wal_checkpoint"]=wasmExports["ge"])(a0,a1);Module["_sqlite3_error_offset"]=a0=>(Module["_sqlite3_error_offset"]=wasmExports["he"])(a0);Module["_sqlite3_errmsg16"]=a0=>(Module["_sqlite3_errmsg16"]=wasmExports["ie"])(a0);Module["_sqlite3_errcode"]=a0=>(Module["_sqlite3_errcode"]=wasmExports["je"])(a0);Module["_sqlite3_extended_errcode"]=a0=>(Module["_sqlite3_extended_errcode"]=wasmExports["ke"])(a0);Module["_sqlite3_system_errno"]=a0=>(Module["_sqlite3_system_errno"]=wasmExports["le"])(a0);Module["_sqlite3_errstr"]=a0=>(Module["_sqlite3_errstr"]=wasmExports["me"])(a0);Module["_sqlite3_limit"]=(a0,a1,a2)=>(Module["_sqlite3_limit"]=wasmExports["ne"])(a0,a1,a2);Module["_sqlite3_open"]=(a0,a1)=>(Module["_sqlite3_open"]=wasmExports["oe"])(a0,a1);Module["_sqlite3_open_v2"]=(a0,a1,a2,a3)=>(Module["_sqlite3_open_v2"]=wasmExports["pe"])(a0,a1,a2,a3);Module["_sqlite3_open16"]=(a0,a1)=>(Module["_sqlite3_open16"]=wasmExports["qe"])(a0,a1);Module["_sqlite3_create_collation"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_create_collation"]=wasmExports["re"])(a0,a1,a2,a3,a4);Module["_sqlite3_create_collation_v2"]=(a0,a1,a2,a3,a4,a5)=>(Module["_sqlite3_create_collation_v2"]=wasmExports["se"])(a0,a1,a2,a3,a4,a5);Module["_sqlite3_create_collation16"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_create_collation16"]=wasmExports["te"])(a0,a1,a2,a3,a4);Module["_sqlite3_collation_needed"]=(a0,a1,a2)=>(Module["_sqlite3_collation_needed"]=wasmExports["ue"])(a0,a1,a2);Module["_sqlite3_collation_needed16"]=(a0,a1,a2)=>(Module["_sqlite3_collation_needed16"]=wasmExports["ve"])(a0,a1,a2);Module["_sqlite3_get_clientdata"]=(a0,a1)=>(Module["_sqlite3_get_clientdata"]=wasmExports["we"])(a0,a1);Module["_sqlite3_set_clientdata"]=(a0,a1,a2,a3)=>(Module["_sqlite3_set_clientdata"]=wasmExports["xe"])(a0,a1,a2,a3);Module["_sqlite3_get_autocommit"]=a0=>(Module["_sqlite3_get_autocommit"]=wasmExports["ye"])(a0);Module["_sqlite3_table_column_metadata"]=(a0,a1,a2,a3,a4,a5,a6,a7,a8)=>(Module["_sqlite3_table_column_metadata"]=wasmExports["ze"])(a0,a1,a2,a3,a4,a5,a6,a7,a8);Module["_sqlite3_sleep"]=a0=>(Module["_sqlite3_sleep"]=wasmExports["Ae"])(a0);Module["_sqlite3_extended_result_codes"]=(a0,a1)=>(Module["_sqlite3_extended_result_codes"]=wasmExports["Be"])(a0,a1);Module["_sqlite3_file_control"]=(a0,a1,a2,a3)=>(Module["_sqlite3_file_control"]=wasmExports["Ce"])(a0,a1,a2,a3);Module["_sqlite3_test_control"]=(a0,a1)=>(Module["_sqlite3_test_control"]=wasmExports["De"])(a0,a1);Module["_sqlite3_create_filename"]=(a0,a1,a2,a3,a4)=>(Module["_sqlite3_create_filename"]=wasmExports["Ee"])(a0,a1,a2,a3,a4);Module["_sqlite3_free_filename"]=a0=>(Module["_sqlite3_free_filename"]=wasmExports["Fe"])(a0);Module["_sqlite3_uri_parameter"]=(a0,a1)=>(Module["_sqlite3_uri_parameter"]=wasmExports["Ge"])(a0,a1);Module["_sqlite3_uri_key"]=(a0,a1)=>(Module["_sqlite3_uri_key"]=wasmExports["He"])(a0,a1);Module["_sqlite3_uri_boolean"]=(a0,a1,a2)=>(Module["_sqlite3_uri_boolean"]=wasmExports["Ie"])(a0,a1,a2);Module["_sqlite3_uri_int64"]=(a0,a1,a2,a3)=>(Module["_sqlite3_uri_int64"]=wasmExports["Je"])(a0,a1,a2,a3);Module["_sqlite3_filename_database"]=a0=>(Module["_sqlite3_filename_database"]=wasmExports["Ke"])(a0);Module["_sqlite3_filename_journal"]=a0=>(Module["_sqlite3_filename_journal"]=wasmExports["Le"])(a0);Module["_sqlite3_filename_wal"]=a0=>(Module["_sqlite3_filename_wal"]=wasmExports["Me"])(a0);Module["_sqlite3_db_name"]=(a0,a1)=>(Module["_sqlite3_db_name"]=wasmExports["Ne"])(a0,a1);Module["_sqlite3_db_filename"]=(a0,a1)=>(Module["_sqlite3_db_filename"]=wasmExports["Oe"])(a0,a1);Module["_sqlite3_db_readonly"]=(a0,a1)=>(Module["_sqlite3_db_readonly"]=wasmExports["Pe"])(a0,a1);Module["_sqlite3_compileoption_used"]=a0=>(Module["_sqlite3_compileoption_used"]=wasmExports["Qe"])(a0);Module["_sqlite3_compileoption_get"]=a0=>(Module["_sqlite3_compileoption_get"]=wasmExports["Re"])(a0);Module["_sqlite3_sourceid"]=()=>(Module["_sqlite3_sourceid"]=wasmExports["Se"])();Module["_malloc"]=a0=>(Module["_malloc"]=wasmExports["Te"])(a0);Module["_free"]=a0=>(Module["_free"]=wasmExports["Ue"])(a0);Module["_RegisterExtensionFunctions"]=a0=>(Module["_RegisterExtensionFunctions"]=wasmExports["Ve"])(a0);Module["_getSqliteFree"]=()=>(Module["_getSqliteFree"]=wasmExports["We"])();var _main=Module["_main"]=(a0,a1)=>(_main=Module["_main"]=wasmExports["Xe"])(a0,a1);Module["_libauthorizer_set_authorizer"]=(a0,a1,a2)=>(Module["_libauthorizer_set_authorizer"]=wasmExports["Ye"])(a0,a1,a2);Module["_libfunction_create_function"]=(a0,a1,a2,a3,a4,a5,a6,a7)=>(Module["_libfunction_create_function"]=wasmExports["Ze"])(a0,a1,a2,a3,a4,a5,a6,a7);Module["_libprogress_progress_handler"]=(a0,a1,a2,a3)=>(Module["_libprogress_progress_handler"]=wasmExports["_e"])(a0,a1,a2,a3);Module["_libvfs_vfs_register"]=(a0,a1,a2,a3,a4,a5)=>(Module["_libvfs_vfs_register"]=wasmExports["$e"])(a0,a1,a2,a3,a4,a5);var _emscripten_builtin_memalign=(a0,a1)=>(_emscripten_builtin_memalign=wasmExports["bf"])(a0,a1);var __emscripten_tempret_get=()=>(__emscripten_tempret_get=wasmExports["cf"])();var __emscripten_stack_restore=a0=>(__emscripten_stack_restore=wasmExports["df"])(a0);var __emscripten_stack_alloc=a0=>(__emscripten_stack_alloc=wasmExports["ef"])(a0);var _emscripten_stack_get_current=()=>(_emscripten_stack_get_current=wasmExports["ff"])();Module["_sqlite3_version"]=5472;Module["getTempRet0"]=getTempRet0;Module["ccall"]=ccall;Module["cwrap"]=cwrap;Module["addFunction"]=addFunction;Module["setValue"]=setValue;Module["getValue"]=getValue;Module["UTF8ToString"]=UTF8ToString;Module["stringToUTF8"]=stringToUTF8;Module["lengthBytesUTF8"]=lengthBytesUTF8;Module["intArrayFromString"]=intArrayFromString;Module["intArrayToString"]=intArrayToString;Module["AsciiToString"]=AsciiToString;Module["UTF16ToString"]=UTF16ToString;Module["stringToUTF16"]=stringToUTF16;Module["UTF32ToString"]=UTF32ToString;Module["stringToUTF32"]=stringToUTF32;Module["writeArrayToMemory"]=writeArrayToMemory;var calledRun;dependenciesFulfilled=function runCaller(){if(!calledRun)run();if(!calledRun)dependenciesFulfilled=runCaller;};function callMain(){var entryFunction=_main;var argc=0;var argv=0;try{var ret=entryFunction(argc,argv);exitJS(ret,true);return ret}catch(e){return handleException(e)}}function run(){if(runDependencies>0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();preMain();readyPromiseResolve(Module);Module["onRuntimeInitialized"]?.();if(shouldRunNow)callMain();postRun();}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("");},1);doRun();},1);}else {doRun();}}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()();}}var shouldRunNow=true;if(Module["noInitialRun"])shouldRunNow=false;run();(function(){const AsyncFunction=Object.getPrototypeOf(async function(){}).constructor;let pAsyncFlags=0;Module["set_authorizer"]=function(db,xAuthorizer,pApp){if(pAsyncFlags){Module["deleteCallback"](pAsyncFlags);Module["_sqlite3_free"](pAsyncFlags);pAsyncFlags=0;}pAsyncFlags=Module["_sqlite3_malloc"](4);setValue(pAsyncFlags,xAuthorizer instanceof AsyncFunction?1:0,"i32");const result=ccall("libauthorizer_set_authorizer","number",["number","number","number"],[db,xAuthorizer?1:0,pAsyncFlags]);if(!result&&xAuthorizer){Module["setCallback"](pAsyncFlags,(_,iAction,p3,p4,p5,p6)=>xAuthorizer(pApp,iAction,p3,p4,p5,p6));}return result};})();(function(){const AsyncFunction=Object.getPrototypeOf(async function(){}).constructor;const FUNC_METHODS=["xFunc","xStep","xFinal"];const mapFunctionNameToKey=new Map;Module["create_function"]=function(db,zFunctionName,nArg,eTextRep,pApp,xFunc,xStep,xFinal){const pAsyncFlags=Module["_sqlite3_malloc"](4);const target={xFunc:xFunc,xStep:xStep,xFinal:xFinal};setValue(pAsyncFlags,FUNC_METHODS.reduce((mask,method,i)=>{if(target[method]instanceof AsyncFunction){return mask|1<xProgress(pApp));}};})();(function(){const VFS_METHODS=["xOpen","xDelete","xAccess","xFullPathname","xRandomness","xSleep","xCurrentTime","xGetLastError","xCurrentTimeInt64","xClose","xRead","xWrite","xTruncate","xSync","xFileSize","xLock","xUnlock","xCheckReservedLock","xFileControl","xSectorSize","xDeviceCharacteristics","xShmMap","xShmLock","xShmBarrier","xShmUnmap"];const mapVFSNameToKey=new Map;Module["vfs_register"]=function(vfs,makeDefault){let methodMask=0;let asyncMask=0;VFS_METHODS.forEach((method,i)=>{if(vfs[method]){methodMask|=1<35aM1 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�K+^0cIi2H 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%0A`l1&Z@X-qYY@d7cfXeWZ0FL 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

2P%@FFAmc+T<)WrDuWys426lcCwPE+hd}^B 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 YQ%F-u(@5X3": + version: 2.3.3 + resolution: "fsevents@patch:fsevents@npm%3A2.3.3#optional!builtin::version=2.3.3&hash=df0bf1" + dependencies: + node-gyp: "npm:latest" + conditions: os=darwin + languageName: node + linkType: hard + +"function-bind@npm:^1.1.2": + version: 1.1.2 + resolution: "function-bind@npm:1.1.2" + checksum: 10/185e20d20f10c8d661d59aac0f3b63b31132d492e1b11fcc2a93cb2c47257ebaee7407c38513efd2b35cafdf972d9beb2ea4593c1e0f3bf8f2744836928d7454 + languageName: node + linkType: hard + +"glob-parent@npm:^5.1.2": + version: 5.1.2 + resolution: "glob-parent@npm:5.1.2" + dependencies: + is-glob: "npm:^4.0.1" + checksum: 10/32cd106ce8c0d83731966d31517adb766d02c3812de49c30cfe0675c7c0ae6630c11214c54a5ae67aca882cf738d27fd7768f21aa19118b9245950554be07247 + languageName: node + linkType: hard + +"glob@npm:^10.2.2, glob@npm:^10.3.10": + version: 10.4.5 + resolution: "glob@npm:10.4.5" + dependencies: + foreground-child: "npm:^3.1.0" + jackspeak: "npm:^3.1.2" + minimatch: "npm:^9.0.4" + minipass: "npm:^7.1.2" + package-json-from-dist: "npm:^1.0.0" + path-scurry: "npm:^1.11.1" + bin: + glob: dist/esm/bin.mjs + checksum: 10/698dfe11828b7efd0514cd11e573eaed26b2dff611f0400907281ce3eab0c1e56143ef9b35adc7c77ecc71fba74717b510c7c223d34ca8a98ec81777b293d4ac + languageName: node + linkType: hard + +"glob@npm:^7.1.3": + version: 7.2.3 + resolution: "glob@npm:7.2.3" + dependencies: + fs.realpath: "npm:^1.0.0" + inflight: "npm:^1.0.4" + inherits: "npm:2" + minimatch: "npm:^3.1.1" + once: "npm:^1.3.0" + path-is-absolute: "npm:^1.0.0" + checksum: 10/59452a9202c81d4508a43b8af7082ca5c76452b9fcc4a9ab17655822e6ce9b21d4f8fbadabe4fe3faef448294cec249af305e2cd824b7e9aaf689240e5e96a7b + languageName: node + linkType: hard + +"globby@npm:10.0.1": + version: 10.0.1 + resolution: "globby@npm:10.0.1" + dependencies: + "@types/glob": "npm:^7.1.1" + array-union: "npm:^2.1.0" + dir-glob: "npm:^3.0.1" + fast-glob: "npm:^3.0.3" + glob: "npm:^7.1.3" + ignore: "npm:^5.1.1" + merge2: "npm:^1.2.3" + slash: "npm:^3.0.0" + checksum: 10/ea724a820d7d4eafc5aa3882d667a7ef3505b3018652b2658185d58752f122b75d3370086e4d4a7b1bbcdf8c2e700e5709a48db189a930df37005e1b3c86c256 + languageName: node + linkType: hard + +"graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.6": + version: 4.2.11 + resolution: "graceful-fs@npm:4.2.11" + checksum: 10/bf152d0ed1dc159239db1ba1f74fdbc40cb02f626770dcd5815c427ce0688c2635a06ed69af364396da4636d0408fcf7d4afdf7881724c3307e46aff30ca49e2 + languageName: node + linkType: hard + +"hasown@npm:^2.0.2": + version: 2.0.2 + resolution: "hasown@npm:2.0.2" + dependencies: + function-bind: "npm:^1.1.2" + checksum: 10/7898a9c1788b2862cf0f9c345a6bec77ba4a0c0983c7f19d610c382343d4f98fa260686b225dfb1f88393a66679d2ec58ee310c1d6868c081eda7918f32cc70a + languageName: node + linkType: hard + +"http-cache-semantics@npm:^4.1.1": + version: 4.1.1 + resolution: "http-cache-semantics@npm:4.1.1" + checksum: 10/362d5ed66b12ceb9c0a328fb31200b590ab1b02f4a254a697dc796850cc4385603e75f53ec59f768b2dad3bfa1464bd229f7de278d2899a0e3beffc634b6683f + languageName: node + linkType: hard + +"http-proxy-agent@npm:^7.0.0": + version: 7.0.2 + resolution: "http-proxy-agent@npm:7.0.2" + dependencies: + agent-base: "npm:^7.1.0" + debug: "npm:^4.3.4" + checksum: 10/d062acfa0cb82beeb558f1043c6ba770ea892b5fb7b28654dbc70ea2aeea55226dd34c02a294f6c1ca179a5aa483c4ea641846821b182edbd9cc5d89b54c6848 + languageName: node + linkType: hard + +"https-proxy-agent@npm:^7.0.1": + version: 7.0.5 + resolution: "https-proxy-agent@npm:7.0.5" + dependencies: + agent-base: "npm:^7.0.2" + debug: "npm:4" + checksum: 10/6679d46159ab3f9a5509ee80c3a3fc83fba3a920a5e18d32176c3327852c3c00ad640c0c4210a8fd70ea3c4a6d3a1b375bf01942516e7df80e2646bdc77658ab + languageName: node + linkType: hard + +"iconv-lite@npm:^0.6.2": + version: 0.6.3 + resolution: "iconv-lite@npm:0.6.3" + dependencies: + safer-buffer: "npm:>= 2.1.2 < 3.0.0" + checksum: 10/24e3292dd3dadaa81d065c6f8c41b274a47098150d444b96e5f53b4638a9a71482921ea6a91a1f59bb71d9796de25e04afd05919fa64c360347ba65d3766f10f + languageName: node + linkType: hard + +"ignore@npm:^5.1.1": + version: 5.3.1 + resolution: "ignore@npm:5.3.1" + checksum: 10/0a884c2fbc8c316f0b9f92beaf84464253b73230a4d4d286697be45fca081199191ca33e1c2e82d9e5f851f5e9a48a78e25a35c951e7eb41e59f150db3530065 + languageName: node + linkType: hard + +"imurmurhash@npm:^0.1.4": + version: 0.1.4 + resolution: "imurmurhash@npm:0.1.4" + checksum: 10/2d30b157a91fe1c1d7c6f653cbf263f039be6c5bfa959245a16d4ee191fc0f2af86c08545b6e6beeb041c56b574d2d5b9f95343d378ab49c0f37394d541e7fc8 + languageName: node + linkType: hard + +"indent-string@npm:^4.0.0": + version: 4.0.0 + resolution: "indent-string@npm:4.0.0" + checksum: 10/cd3f5cbc9ca2d624c6a1f53f12e6b341659aba0e2d3254ae2b4464aaea8b4294cdb09616abbc59458f980531f2429784ed6a420d48d245bcad0811980c9efae9 + languageName: node + linkType: hard + +"inflight@npm:^1.0.4": + version: 1.0.6 + resolution: "inflight@npm:1.0.6" + dependencies: + once: "npm:^1.3.0" + wrappy: "npm:1" + checksum: 10/d2ebd65441a38c8336c223d1b80b921b9fa737e37ea466fd7e253cb000c64ae1f17fa59e68130ef5bda92cfd8d36b83d37dab0eb0a4558bcfec8e8cdfd2dcb67 + languageName: node + linkType: hard + +"inherits@npm:2": + version: 2.0.4 + resolution: "inherits@npm:2.0.4" + checksum: 10/cd45e923bee15186c07fa4c89db0aace24824c482fb887b528304694b2aa6ff8a898da8657046a5dcf3e46cd6db6c61629551f9215f208d7c3f157cf9b290521 + languageName: node + linkType: hard + +"ip-address@npm:^9.0.5": + version: 9.0.5 + resolution: "ip-address@npm:9.0.5" + dependencies: + jsbn: "npm:1.1.0" + sprintf-js: "npm:^1.1.3" + checksum: 10/1ed81e06721af012306329b31f532b5e24e00cb537be18ddc905a84f19fe8f83a09a1699862bf3a1ec4b9dea93c55a3fa5faf8b5ea380431469df540f38b092c + languageName: node + linkType: hard + +"is-builtin-module@npm:^3.2.1": + version: 3.2.1 + resolution: "is-builtin-module@npm:3.2.1" + dependencies: + builtin-modules: "npm:^3.3.0" + checksum: 10/e8f0ffc19a98240bda9c7ada84d846486365af88d14616e737d280d378695c8c448a621dcafc8332dbf0fcd0a17b0763b845400709963fa9151ddffece90ae88 + languageName: node + linkType: hard + +"is-core-module@npm:^2.13.0": + version: 2.15.0 + resolution: "is-core-module@npm:2.15.0" + dependencies: + hasown: "npm:^2.0.2" + checksum: 10/70e962543e5d3a97c07cb29144a86792d545a21f28e67da5401d85878a0193d46fbab8d97bc3ca680e2778705dca66e7b6ca840c493497a27ca0e8c5f3ac3d1d + languageName: node + linkType: hard + +"is-extglob@npm:^2.1.1": + version: 2.1.1 + resolution: "is-extglob@npm:2.1.1" + checksum: 10/df033653d06d0eb567461e58a7a8c9f940bd8c22274b94bf7671ab36df5719791aae15eef6d83bbb5e23283967f2f984b8914559d4449efda578c775c4be6f85 + languageName: node + linkType: hard + +"is-fullwidth-code-point@npm:^3.0.0": + version: 3.0.0 + resolution: "is-fullwidth-code-point@npm:3.0.0" + checksum: 10/44a30c29457c7fb8f00297bce733f0a64cd22eca270f83e58c105e0d015e45c019491a4ab2faef91ab51d4738c670daff901c799f6a700e27f7314029e99e348 + languageName: node + linkType: hard + +"is-glob@npm:^4.0.1": + version: 4.0.3 + resolution: "is-glob@npm:4.0.3" + dependencies: + is-extglob: "npm:^2.1.1" + checksum: 10/3ed74f2b0cdf4f401f38edb0442ddfde3092d79d7d35c9919c86641efdbcbb32e45aa3c0f70ce5eecc946896cd5a0f26e4188b9f2b881876f7cb6c505b82da11 + languageName: node + linkType: hard + +"is-lambda@npm:^1.0.1": + version: 1.0.1 + resolution: "is-lambda@npm:1.0.1" + checksum: 10/93a32f01940220532e5948538699ad610d5924ac86093fcee83022252b363eb0cc99ba53ab084a04e4fb62bf7b5731f55496257a4c38adf87af9c4d352c71c35 + languageName: node + linkType: hard + +"is-module@npm:^1.0.0": + version: 1.0.0 + resolution: "is-module@npm:1.0.0" + checksum: 10/8cd5390730c7976fb4e8546dd0b38865ee6f7bacfa08dfbb2cc07219606755f0b01709d9361e01f13009bbbd8099fa2927a8ed665118a6105d66e40f1b838c3f + languageName: node + linkType: hard + +"is-number@npm:^7.0.0": + version: 7.0.0 + resolution: "is-number@npm:7.0.0" + checksum: 10/6a6c3383f68afa1e05b286af866017c78f1226d43ac8cb064e115ff9ed85eb33f5c4f7216c96a71e4dfea289ef52c5da3aef5bbfade8ffe47a0465d70c0c8e86 + languageName: node + linkType: hard + +"is-plain-object@npm:^3.0.0": + version: 3.0.1 + resolution: "is-plain-object@npm:3.0.1" + checksum: 10/d13fe75db350d4ac669595cdfe0242ae87fcecddf2bca858d2dd443a6ed6eb1f69951fac8c2fa85b16106c6b0d7738fea86c2aca2ecee7fd61de15c1574f2cc5 + languageName: node + linkType: hard + +"isexe@npm:^2.0.0": + version: 2.0.0 + resolution: "isexe@npm:2.0.0" + checksum: 10/7c9f715c03aff08f35e98b1fadae1b9267b38f0615d501824f9743f3aab99ef10e303ce7db3f186763a0b70a19de5791ebfc854ff884d5a8c4d92211f642ec92 + languageName: node + linkType: hard + +"isexe@npm:^3.1.1": + version: 3.1.1 + resolution: "isexe@npm:3.1.1" + checksum: 10/7fe1931ee4e88eb5aa524cd3ceb8c882537bc3a81b02e438b240e47012eef49c86904d0f0e593ea7c3a9996d18d0f1f3be8d3eaa92333977b0c3a9d353d5563e + languageName: node + linkType: hard + +"jackspeak@npm:^3.1.2": + version: 3.4.3 + resolution: "jackspeak@npm:3.4.3" + dependencies: + "@isaacs/cliui": "npm:^8.0.2" + "@pkgjs/parseargs": "npm:^0.11.0" + dependenciesMeta: + "@pkgjs/parseargs": + optional: true + checksum: 10/96f8786eaab98e4bf5b2a5d6d9588ea46c4d06bbc4f2eb861fdd7b6b182b16f71d8a70e79820f335d52653b16d4843b29dd9cdcf38ae80406756db9199497cf3 + languageName: node + linkType: hard + +"jsbn@npm:1.1.0": + version: 1.1.0 + resolution: "jsbn@npm:1.1.0" + checksum: 10/bebe7ae829bbd586ce8cbe83501dd8cb8c282c8902a8aeeed0a073a89dc37e8103b1244f3c6acd60278bcbfe12d93a3f83c9ac396868a3b3bbc3c5e5e3b648ef + languageName: node + linkType: hard + +"jsonfile@npm:^4.0.0": + version: 4.0.0 + resolution: "jsonfile@npm:4.0.0" + dependencies: + graceful-fs: "npm:^4.1.6" + dependenciesMeta: + graceful-fs: + optional: true + checksum: 10/17796f0ab1be8479827d3683433f97ebe0a1c6932c3360fa40348eac36904d69269aab26f8b16da311882d94b42e9208e8b28e490bf926364f3ac9bff134c226 + languageName: node + linkType: hard + +"lru-cache@npm:^10.0.1, lru-cache@npm:^10.2.0": + version: 10.4.3 + resolution: "lru-cache@npm:10.4.3" + checksum: 10/e6e90267360476720fa8e83cc168aa2bf0311f3f2eea20a6ba78b90a885ae72071d9db132f40fda4129c803e7dcec3a6b6a6fbb44ca90b081630b810b5d6a41a + languageName: node + linkType: hard + +"make-fetch-happen@npm:^13.0.0": + version: 13.0.1 + resolution: "make-fetch-happen@npm:13.0.1" + dependencies: + "@npmcli/agent": "npm:^2.0.0" + cacache: "npm:^18.0.0" + http-cache-semantics: "npm:^4.1.1" + is-lambda: "npm:^1.0.1" + minipass: "npm:^7.0.2" + minipass-fetch: "npm:^3.0.0" + minipass-flush: "npm:^1.0.5" + minipass-pipeline: "npm:^1.2.4" + negotiator: "npm:^0.6.3" + proc-log: "npm:^4.2.0" + promise-retry: "npm:^2.0.1" + ssri: "npm:^10.0.0" + checksum: 10/11bae5ad6ac59b654dbd854f30782f9de052186c429dfce308eda42374528185a100ee40ac9ffdc36a2b6c821ecaba43913e4730a12f06f15e895ea9cb23fa59 + languageName: node + linkType: hard + +"merge2@npm:^1.2.3, merge2@npm:^1.3.0": + version: 1.4.1 + resolution: "merge2@npm:1.4.1" + checksum: 10/7268db63ed5169466540b6fb947aec313200bcf6d40c5ab722c22e242f651994619bcd85601602972d3c85bd2cc45a358a4c61937e9f11a061919a1da569b0c2 + languageName: node + linkType: hard + +"micromatch@npm:^4.0.4": + version: 4.0.7 + resolution: "micromatch@npm:4.0.7" + dependencies: + braces: "npm:^3.0.3" + picomatch: "npm:^2.3.1" + checksum: 10/a11ed1cb67dcbbe9a5fc02c4062cf8bb0157d73bf86956003af8dcfdf9b287f9e15ec0f6d6925ff6b8b5b496202335e497b01de4d95ef6cf06411bc5e5c474a0 + languageName: node + linkType: hard + +"minimatch@npm:^3.1.1": + version: 3.1.2 + resolution: "minimatch@npm:3.1.2" + dependencies: + brace-expansion: "npm:^1.1.7" + checksum: 10/e0b25b04cd4ec6732830344e5739b13f8690f8a012d73445a4a19fbc623f5dd481ef7a5827fde25954cd6026fede7574cc54dc4643c99d6c6b653d6203f94634 + languageName: node + linkType: hard + +"minimatch@npm:^9.0.4": + version: 9.0.5 + resolution: "minimatch@npm:9.0.5" + dependencies: + brace-expansion: "npm:^2.0.1" + checksum: 10/dd6a8927b063aca6d910b119e1f2df6d2ce7d36eab91de83167dd136bb85e1ebff97b0d3de1cb08bd1f7e018ca170b4962479fefab5b2a69e2ae12cb2edc8348 + languageName: node + linkType: hard + +"minipass-collect@npm:^2.0.1": + version: 2.0.1 + resolution: "minipass-collect@npm:2.0.1" + dependencies: + minipass: "npm:^7.0.3" + checksum: 10/b251bceea62090f67a6cced7a446a36f4cd61ee2d5cea9aee7fff79ba8030e416327a1c5aa2908dc22629d06214b46d88fdab8c51ac76bacbf5703851b5ad342 + languageName: node + linkType: hard + +"minipass-fetch@npm:^3.0.0": + version: 3.0.5 + resolution: "minipass-fetch@npm:3.0.5" + dependencies: + encoding: "npm:^0.1.13" + minipass: "npm:^7.0.3" + minipass-sized: "npm:^1.0.3" + minizlib: "npm:^2.1.2" + dependenciesMeta: + encoding: + optional: true + checksum: 10/c669948bec1373313aaa8f104b962a3ced9f45c49b26366a4b0ae27ccdfa9c5740d72c8a84d3f8623d7a61c5fc7afdfda44789008c078f61a62441142efc4a97 + languageName: node + linkType: hard + +"minipass-flush@npm:^1.0.5": + version: 1.0.5 + resolution: "minipass-flush@npm:1.0.5" + dependencies: + minipass: "npm:^3.0.0" + checksum: 10/56269a0b22bad756a08a94b1ffc36b7c9c5de0735a4dd1ab2b06c066d795cfd1f0ac44a0fcae13eece5589b908ecddc867f04c745c7009be0b566421ea0944cf + languageName: node + linkType: hard + +"minipass-pipeline@npm:^1.2.4": + version: 1.2.4 + resolution: "minipass-pipeline@npm:1.2.4" + dependencies: + minipass: "npm:^3.0.0" + checksum: 10/b14240dac0d29823c3d5911c286069e36d0b81173d7bdf07a7e4a91ecdef92cdff4baaf31ea3746f1c61e0957f652e641223970870e2353593f382112257971b + languageName: node + linkType: hard + +"minipass-sized@npm:^1.0.3": + version: 1.0.3 + resolution: "minipass-sized@npm:1.0.3" + dependencies: + minipass: "npm:^3.0.0" + checksum: 10/40982d8d836a52b0f37049a0a7e5d0f089637298e6d9b45df9c115d4f0520682a78258905e5c8b180fb41b593b0a82cc1361d2c74b45f7ada66334f84d1ecfdd + languageName: node + linkType: hard + +"minipass@npm:^3.0.0": + version: 3.3.6 + resolution: "minipass@npm:3.3.6" + dependencies: + yallist: "npm:^4.0.0" + checksum: 10/a5c6ef069f70d9a524d3428af39f2b117ff8cd84172e19b754e7264a33df460873e6eb3d6e55758531580970de50ae950c496256bb4ad3691a2974cddff189f0 + languageName: node + linkType: hard + +"minipass@npm:^5.0.0": + version: 5.0.0 + resolution: "minipass@npm:5.0.0" + checksum: 10/61682162d29f45d3152b78b08bab7fb32ca10899bc5991ffe98afc18c9e9543bd1e3be94f8b8373ba6262497db63607079dc242ea62e43e7b2270837b7347c93 + languageName: node + linkType: hard + +"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.2, minipass@npm:^7.0.3, minipass@npm:^7.1.2": + version: 7.1.2 + resolution: "minipass@npm:7.1.2" + checksum: 10/c25f0ee8196d8e6036661104bacd743785b2599a21de5c516b32b3fa2b83113ac89a2358465bc04956baab37ffb956ae43be679b2262bf7be15fce467ccd7950 + languageName: node + linkType: hard + +"minizlib@npm:^2.1.1, minizlib@npm:^2.1.2": + version: 2.1.2 + resolution: "minizlib@npm:2.1.2" + dependencies: + minipass: "npm:^3.0.0" + yallist: "npm:^4.0.0" + checksum: 10/ae0f45436fb51344dcb87938446a32fbebb540d0e191d63b35e1c773d47512e17307bf54aa88326cc6d176594d00e4423563a091f7266c2f9a6872cdc1e234d1 + languageName: node + linkType: hard + +"mkdirp@npm:^1.0.3": + version: 1.0.4 + resolution: "mkdirp@npm:1.0.4" + bin: + mkdirp: bin/cmd.js + checksum: 10/d71b8dcd4b5af2fe13ecf3bd24070263489404fe216488c5ba7e38ece1f54daf219e72a833a3a2dc404331e870e9f44963a33399589490956bff003a3404d3b2 + languageName: node + linkType: hard + +"ms@npm:2.1.2": + version: 2.1.2 + resolution: "ms@npm:2.1.2" + checksum: 10/673cdb2c3133eb050c745908d8ce632ed2c02d85640e2edb3ace856a2266a813b30c613569bf3354fdf4ea7d1a1494add3bfa95e2713baa27d0c2c71fc44f58f + languageName: node + linkType: hard + +"negotiator@npm:^0.6.3": + version: 0.6.3 + resolution: "negotiator@npm:0.6.3" + checksum: 10/2723fb822a17ad55c93a588a4bc44d53b22855bf4be5499916ca0cab1e7165409d0b288ba2577d7b029f10ce18cf2ed8e703e5af31c984e1e2304277ef979837 + languageName: node + linkType: hard + +"node-gyp@npm:latest": + version: 10.2.0 + resolution: "node-gyp@npm:10.2.0" + dependencies: + env-paths: "npm:^2.2.0" + exponential-backoff: "npm:^3.1.1" + glob: "npm:^10.3.10" + graceful-fs: "npm:^4.2.6" + make-fetch-happen: "npm:^13.0.0" + nopt: "npm:^7.0.0" + proc-log: "npm:^4.1.0" + semver: "npm:^7.3.5" + tar: "npm:^6.2.1" + which: "npm:^4.0.0" + bin: + node-gyp: bin/node-gyp.js + checksum: 10/41773093b1275751dec942b985982fd4e7a69b88cae719b868babcef3880ee6168aaec8dcaa8cd0b9fa7c84873e36cc549c6cac6a124ee65ba4ce1f1cc108cfe + languageName: node + linkType: hard + +"nopt@npm:^7.0.0": + version: 7.2.1 + resolution: "nopt@npm:7.2.1" + dependencies: + abbrev: "npm:^2.0.0" + bin: + nopt: bin/nopt.js + checksum: 10/95a1f6dec8a81cd18cdc2fed93e6f0b4e02cf6bdb4501c848752c6e34f9883d9942f036a5e3b21a699047d8a448562d891e67492df68ec9c373e6198133337ae + languageName: node + linkType: hard + +"once@npm:^1.3.0": + version: 1.4.0 + resolution: "once@npm:1.4.0" + dependencies: + wrappy: "npm:1" + checksum: 10/cd0a88501333edd640d95f0d2700fbde6bff20b3d4d9bdc521bdd31af0656b5706570d6c6afe532045a20bb8dc0849f8332d6f2a416e0ba6d3d3b98806c7db68 + languageName: node + linkType: hard + +"p-map@npm:^4.0.0": + version: 4.0.0 + resolution: "p-map@npm:4.0.0" + dependencies: + aggregate-error: "npm:^3.0.0" + checksum: 10/7ba4a2b1e24c05e1fc14bbaea0fc6d85cf005ae7e9c9425d4575550f37e2e584b1af97bcde78eacd7559208f20995988d52881334db16cf77bc1bcf68e48ed7c + languageName: node + linkType: hard + +"package-json-from-dist@npm:^1.0.0": + version: 1.0.0 + resolution: "package-json-from-dist@npm:1.0.0" + checksum: 10/ac706ec856a5a03f5261e4e48fa974f24feb044d51f84f8332e2af0af04fbdbdd5bbbfb9cbbe354190409bc8307c83a9e38c6672c3c8855f709afb0006a009ea + languageName: node + linkType: hard + +"path-is-absolute@npm:^1.0.0": + version: 1.0.1 + resolution: "path-is-absolute@npm:1.0.1" + checksum: 10/060840f92cf8effa293bcc1bea81281bd7d363731d214cbe5c227df207c34cd727430f70c6037b5159c8a870b9157cba65e775446b0ab06fd5ecc7e54615a3b8 + languageName: node + linkType: hard + +"path-key@npm:^3.1.0": + version: 3.1.1 + resolution: "path-key@npm:3.1.1" + checksum: 10/55cd7a9dd4b343412a8386a743f9c746ef196e57c823d90ca3ab917f90ab9f13dd0ded27252ba49dbdfcab2b091d998bc446f6220cd3cea65db407502a740020 + languageName: node + linkType: hard + +"path-parse@npm:^1.0.7": + version: 1.0.7 + resolution: "path-parse@npm:1.0.7" + checksum: 10/49abf3d81115642938a8700ec580da6e830dde670be21893c62f4e10bd7dd4c3742ddc603fe24f898cba7eb0c6bc1777f8d9ac14185d34540c6d4d80cd9cae8a + languageName: node + linkType: hard + +"path-scurry@npm:^1.11.1": + version: 1.11.1 + resolution: "path-scurry@npm:1.11.1" + dependencies: + lru-cache: "npm:^10.2.0" + minipass: "npm:^5.0.0 || ^6.0.2 || ^7.0.0" + checksum: 10/5e8845c159261adda6f09814d7725683257fcc85a18f329880ab4d7cc1d12830967eae5d5894e453f341710d5484b8fdbbd4d75181b4d6e1eb2f4dc7aeadc434 + languageName: node + linkType: hard + +"path-type@npm:^4.0.0": + version: 4.0.0 + resolution: "path-type@npm:4.0.0" + checksum: 10/5b1e2daa247062061325b8fdbfd1fb56dde0a448fb1455453276ea18c60685bdad23a445dc148cf87bc216be1573357509b7d4060494a6fd768c7efad833ee45 + languageName: node + linkType: hard + +"picomatch@npm:^2.3.1": + version: 2.3.1 + resolution: "picomatch@npm:2.3.1" + checksum: 10/60c2595003b05e4535394d1da94850f5372c9427ca4413b71210f437f7b2ca091dbd611c45e8b37d10036fa8eade25c1b8951654f9d3973bfa66a2ff4d3b08bc + languageName: node + linkType: hard + +"proc-log@npm:^4.1.0, proc-log@npm:^4.2.0": + version: 4.2.0 + resolution: "proc-log@npm:4.2.0" + checksum: 10/4e1394491b717f6c1ade15c570ecd4c2b681698474d3ae2d303c1e4b6ab9455bd5a81566211e82890d5a5ae9859718cc6954d5150bb18b09b72ecb297beae90a + languageName: node + linkType: hard + +"promise-retry@npm:^2.0.1": + version: 2.0.1 + resolution: "promise-retry@npm:2.0.1" + dependencies: + err-code: "npm:^2.0.2" + retry: "npm:^0.12.0" + checksum: 10/96e1a82453c6c96eef53a37a1d6134c9f2482f94068f98a59145d0986ca4e497bf110a410adf73857e588165eab3899f0ebcf7b3890c1b3ce802abc0d65967d4 + languageName: node + linkType: hard + +"queue-microtask@npm:^1.2.2": + version: 1.2.3 + resolution: "queue-microtask@npm:1.2.3" + checksum: 10/72900df0616e473e824202113c3df6abae59150dfb73ed13273503127235320e9c8ca4aaaaccfd58cf417c6ca92a6e68ee9a5c3182886ae949a768639b388a7b + languageName: node + linkType: hard + +"resolve@npm:^1.22.1": + version: 1.22.8 + resolution: "resolve@npm:1.22.8" + dependencies: + is-core-module: "npm:^2.13.0" + path-parse: "npm:^1.0.7" + supports-preserve-symlinks-flag: "npm:^1.0.0" + bin: + resolve: bin/resolve + checksum: 10/c473506ee01eb45cbcfefb68652ae5759e092e6b0fb64547feadf9736a6394f258fbc6f88e00c5ca36d5477fbb65388b272432a3600fa223062e54333c156753 + languageName: node + linkType: hard + +"resolve@patch:resolve@npm%3A^1.22.1#optional!builtin": + version: 1.22.8 + resolution: "resolve@patch:resolve@npm%3A1.22.8#optional!builtin::version=1.22.8&hash=c3c19d" + dependencies: + is-core-module: "npm:^2.13.0" + path-parse: "npm:^1.0.7" + supports-preserve-symlinks-flag: "npm:^1.0.0" + bin: + resolve: bin/resolve + checksum: 10/f345cd37f56a2c0275e3fe062517c650bb673815d885e7507566df589375d165bbbf4bdb6aa95600a9bc55f4744b81f452b5a63f95b9f10a72787dba3c90890a + languageName: node + linkType: hard + +"retry@npm:^0.12.0": + version: 0.12.0 + resolution: "retry@npm:0.12.0" + checksum: 10/1f914879f97e7ee931ad05fe3afa629bd55270fc6cf1c1e589b6a99fab96d15daad0fa1a52a00c729ec0078045fe3e399bd4fd0c93bcc906957bdc17f89cb8e6 + languageName: node + linkType: hard + +"reusify@npm:^1.0.4": + version: 1.0.4 + resolution: "reusify@npm:1.0.4" + checksum: 10/14222c9e1d3f9ae01480c50d96057228a8524706db79cdeb5a2ce5bb7070dd9f409a6f84a02cbef8cdc80d39aef86f2dd03d155188a1300c599b05437dcd2ffb + languageName: node + linkType: hard + +"rollup-plugin-copy@npm:^3.5.0": + version: 3.5.0 + resolution: "rollup-plugin-copy@npm:3.5.0" + dependencies: + "@types/fs-extra": "npm:^8.0.1" + colorette: "npm:^1.1.0" + fs-extra: "npm:^8.1.0" + globby: "npm:10.0.1" + is-plain-object: "npm:^3.0.0" + checksum: 10/706ba6bd2052b95d1037f12963ff4b50749730f18aefad10544f9574aff7c035c88c5dd9ae1f0c0408cf09862e595a0ea4d68e13c2717addaea2bda3ade0d0e0 + languageName: node + linkType: hard + +"rollup@npm:^4.19.0": + version: 4.19.0 + resolution: "rollup@npm:4.19.0" + dependencies: + "@rollup/rollup-android-arm-eabi": "npm:4.19.0" + "@rollup/rollup-android-arm64": "npm:4.19.0" + "@rollup/rollup-darwin-arm64": "npm:4.19.0" + "@rollup/rollup-darwin-x64": "npm:4.19.0" + "@rollup/rollup-linux-arm-gnueabihf": "npm:4.19.0" + "@rollup/rollup-linux-arm-musleabihf": "npm:4.19.0" + "@rollup/rollup-linux-arm64-gnu": "npm:4.19.0" + "@rollup/rollup-linux-arm64-musl": "npm:4.19.0" + "@rollup/rollup-linux-powerpc64le-gnu": "npm:4.19.0" + "@rollup/rollup-linux-riscv64-gnu": "npm:4.19.0" + "@rollup/rollup-linux-s390x-gnu": "npm:4.19.0" + "@rollup/rollup-linux-x64-gnu": "npm:4.19.0" + "@rollup/rollup-linux-x64-musl": "npm:4.19.0" + "@rollup/rollup-win32-arm64-msvc": "npm:4.19.0" + "@rollup/rollup-win32-ia32-msvc": "npm:4.19.0" + "@rollup/rollup-win32-x64-msvc": "npm:4.19.0" + "@types/estree": "npm:1.0.5" + fsevents: "npm:~2.3.2" + dependenciesMeta: + "@rollup/rollup-android-arm-eabi": + optional: true + "@rollup/rollup-android-arm64": + optional: true + "@rollup/rollup-darwin-arm64": + optional: true + "@rollup/rollup-darwin-x64": + optional: true + "@rollup/rollup-linux-arm-gnueabihf": + optional: true + "@rollup/rollup-linux-arm-musleabihf": + optional: true + "@rollup/rollup-linux-arm64-gnu": + optional: true + "@rollup/rollup-linux-arm64-musl": + optional: true + "@rollup/rollup-linux-powerpc64le-gnu": + optional: true + "@rollup/rollup-linux-riscv64-gnu": + optional: true + "@rollup/rollup-linux-s390x-gnu": + optional: true + "@rollup/rollup-linux-x64-gnu": + optional: true + "@rollup/rollup-linux-x64-musl": + optional: true + "@rollup/rollup-win32-arm64-msvc": + optional: true + "@rollup/rollup-win32-ia32-msvc": + optional: true + "@rollup/rollup-win32-x64-msvc": + optional: true + fsevents: + optional: true + bin: + rollup: dist/bin/rollup + checksum: 10/a5f56e60d160e727f372fb0b0adbab03c1e5b858df7af62e626459687e6510d5b9685e4badef50bb6ffd916eaf53c1684a8e12ae959dacb8e6930c77a00a0f19 + languageName: node + linkType: hard + +"run-parallel@npm:^1.1.9": + version: 1.2.0 + resolution: "run-parallel@npm:1.2.0" + dependencies: + queue-microtask: "npm:^1.2.2" + checksum: 10/cb4f97ad25a75ebc11a8ef4e33bb962f8af8516bb2001082ceabd8902e15b98f4b84b4f8a9b222e5d57fc3bd1379c483886ed4619367a7680dad65316993021d + languageName: node + linkType: hard + +"safer-buffer@npm:>= 2.1.2 < 3.0.0": + version: 2.1.2 + resolution: "safer-buffer@npm:2.1.2" + checksum: 10/7eaf7a0cf37cc27b42fb3ef6a9b1df6e93a1c6d98c6c6702b02fe262d5fcbd89db63320793b99b21cb5348097d0a53de81bd5f4e8b86e20cc9412e3f1cfb4e83 + languageName: node + linkType: hard + +"semver@npm:^7.3.5": + version: 7.6.3 + resolution: "semver@npm:7.6.3" + bin: + semver: bin/semver.js + checksum: 10/36b1fbe1a2b6f873559cd57b238f1094a053dbfd997ceeb8757d79d1d2089c56d1321b9f1069ce263dc64cfa922fa1d2ad566b39426fe1ac6c723c1487589e10 + languageName: node + linkType: hard + +"shebang-command@npm:^2.0.0": + version: 2.0.0 + resolution: "shebang-command@npm:2.0.0" + dependencies: + shebang-regex: "npm:^3.0.0" + checksum: 10/6b52fe87271c12968f6a054e60f6bde5f0f3d2db483a1e5c3e12d657c488a15474121a1d55cd958f6df026a54374ec38a4a963988c213b7570e1d51575cea7fa + languageName: node + linkType: hard + +"shebang-regex@npm:^3.0.0": + version: 3.0.0 + resolution: "shebang-regex@npm:3.0.0" + checksum: 10/1a2bcae50de99034fcd92ad4212d8e01eedf52c7ec7830eedcf886622804fe36884278f2be8be0ea5fde3fd1c23911643a4e0f726c8685b61871c8908af01222 + languageName: node + linkType: hard + +"signal-exit@npm:^4.0.1": + version: 4.1.0 + resolution: "signal-exit@npm:4.1.0" + checksum: 10/c9fa63bbbd7431066174a48ba2dd9986dfd930c3a8b59de9c29d7b6854ec1c12a80d15310869ea5166d413b99f041bfa3dd80a7947bcd44ea8e6eb3ffeabfa1f + languageName: node + linkType: hard + +"slash@npm:^3.0.0": + version: 3.0.0 + resolution: "slash@npm:3.0.0" + checksum: 10/94a93fff615f25a999ad4b83c9d5e257a7280c90a32a7cb8b4a87996e4babf322e469c42b7f649fd5796edd8687652f3fb452a86dc97a816f01113183393f11c + languageName: node + linkType: hard + +"smart-buffer@npm:^4.2.0": + version: 4.2.0 + resolution: "smart-buffer@npm:4.2.0" + checksum: 10/927484aa0b1640fd9473cee3e0a0bcad6fce93fd7bbc18bac9ad0c33686f5d2e2c422fba24b5899c184524af01e11dd2bd051c2bf2b07e47aff8ca72cbfc60d2 + languageName: node + linkType: hard + +"socks-proxy-agent@npm:^8.0.3": + version: 8.0.4 + resolution: "socks-proxy-agent@npm:8.0.4" + dependencies: + agent-base: "npm:^7.1.1" + debug: "npm:^4.3.4" + socks: "npm:^2.8.3" + checksum: 10/c8e7c2b398338b49a0a0f4d2bae5c0602aeeca6b478b99415927b6c5db349ca258448f2c87c6958ebf83eea17d42cbc5d1af0bfecb276cac10b9658b0f07f7d7 + languageName: node + linkType: hard + +"socks@npm:^2.8.3": + version: 2.8.3 + resolution: "socks@npm:2.8.3" + dependencies: + ip-address: "npm:^9.0.5" + smart-buffer: "npm:^4.2.0" + checksum: 10/ffcb622c22481dfcd7589aae71fbfd71ca34334064d181df64bf8b7feaeee19706aba4cffd1de35cc7bbaeeaa0af96be2d7f40fcbc7bc0ab69533a7ae9ffc4fb + languageName: node + linkType: hard + +"sprintf-js@npm:^1.1.3": + version: 1.1.3 + resolution: "sprintf-js@npm:1.1.3" + checksum: 10/e7587128c423f7e43cc625fe2f87e6affdf5ca51c1cc468e910d8aaca46bb44a7fbcfa552f787b1d3987f7043aeb4527d1b99559e6621e01b42b3f45e5a24cbb + languageName: node + linkType: hard + +"ssri@npm:^10.0.0": + version: 10.0.6 + resolution: "ssri@npm:10.0.6" + dependencies: + minipass: "npm:^7.0.3" + checksum: 10/f92c1b3cc9bfd0a925417412d07d999935917bc87049f43ebec41074661d64cf720315661844106a77da9f8204b6d55ae29f9514e673083cae39464343af2a8b + languageName: node + linkType: hard + +"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^4.1.0": + version: 4.2.3 + resolution: "string-width@npm:4.2.3" + dependencies: + emoji-regex: "npm:^8.0.0" + is-fullwidth-code-point: "npm:^3.0.0" + strip-ansi: "npm:^6.0.1" + checksum: 10/e52c10dc3fbfcd6c3a15f159f54a90024241d0f149cf8aed2982a2d801d2e64df0bf1dc351cf8e95c3319323f9f220c16e740b06faecd53e2462df1d2b5443fb + languageName: node + linkType: hard + +"string-width@npm:^5.0.1, string-width@npm:^5.1.2": + version: 5.1.2 + resolution: "string-width@npm:5.1.2" + dependencies: + eastasianwidth: "npm:^0.2.0" + emoji-regex: "npm:^9.2.2" + strip-ansi: "npm:^7.0.1" + checksum: 10/7369deaa29f21dda9a438686154b62c2c5f661f8dda60449088f9f980196f7908fc39fdd1803e3e01541970287cf5deae336798337e9319a7055af89dafa7193 + languageName: node + linkType: hard + +"strip-ansi-cjs@npm:strip-ansi@^6.0.1, strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1": + version: 6.0.1 + resolution: "strip-ansi@npm:6.0.1" + dependencies: + ansi-regex: "npm:^5.0.1" + checksum: 10/ae3b5436d34fadeb6096367626ce987057713c566e1e7768818797e00ac5d62023d0f198c4e681eae9e20701721980b26a64a8f5b91238869592a9c6800719a2 + languageName: node + linkType: hard + +"strip-ansi@npm:^7.0.1": + version: 7.1.0 + resolution: "strip-ansi@npm:7.1.0" + dependencies: + ansi-regex: "npm:^6.0.1" + checksum: 10/475f53e9c44375d6e72807284024ac5d668ee1d06010740dec0b9744f2ddf47de8d7151f80e5f6190fc8f384e802fdf9504b76a7e9020c9faee7103623338be2 + languageName: node + linkType: hard + +"supports-preserve-symlinks-flag@npm:^1.0.0": + version: 1.0.0 + resolution: "supports-preserve-symlinks-flag@npm:1.0.0" + checksum: 10/a9dc19ae2220c952bd2231d08ddeecb1b0328b61e72071ff4000c8384e145cc07c1c0bdb3b5a1cb06e186a7b2790f1dee793418b332f6ddf320de25d9125be7e + languageName: node + linkType: hard + +"tar@npm:^6.1.11, tar@npm:^6.2.1": + version: 6.2.1 + resolution: "tar@npm:6.2.1" + dependencies: + chownr: "npm:^2.0.0" + fs-minipass: "npm:^2.0.0" + minipass: "npm:^5.0.0" + minizlib: "npm:^2.1.1" + mkdirp: "npm:^1.0.3" + yallist: "npm:^4.0.0" + checksum: 10/bfbfbb2861888077fc1130b84029cdc2721efb93d1d1fb80f22a7ac3a98ec6f8972f29e564103bbebf5e97be67ebc356d37fa48dbc4960600a1eb7230fbd1ea0 + languageName: node + linkType: hard + +"to-regex-range@npm:^5.0.1": + version: 5.0.1 + resolution: "to-regex-range@npm:5.0.1" + dependencies: + is-number: "npm:^7.0.0" + checksum: 10/10dda13571e1f5ad37546827e9b6d4252d2e0bc176c24a101252153ef435d83696e2557fe128c4678e4e78f5f01e83711c703eef9814eb12dab028580d45980a + languageName: node + linkType: hard + +"undici-types@npm:~5.26.4": + version: 5.26.5 + resolution: "undici-types@npm:5.26.5" + checksum: 10/0097779d94bc0fd26f0418b3a05472410408877279141ded2bd449167be1aed7ea5b76f756562cb3586a07f251b90799bab22d9019ceba49c037c76445f7cddd + languageName: node + linkType: hard + +"unique-filename@npm:^3.0.0": + version: 3.0.0 + resolution: "unique-filename@npm:3.0.0" + dependencies: + unique-slug: "npm:^4.0.0" + checksum: 10/8e2f59b356cb2e54aab14ff98a51ac6c45781d15ceaab6d4f1c2228b780193dc70fae4463ce9e1df4479cb9d3304d7c2043a3fb905bdeca71cc7e8ce27e063df + languageName: node + linkType: hard + +"unique-slug@npm:^4.0.0": + version: 4.0.0 + resolution: "unique-slug@npm:4.0.0" + dependencies: + imurmurhash: "npm:^0.1.4" + checksum: 10/40912a8963fc02fb8b600cf50197df4a275c602c60de4cac4f75879d3c48558cfac48de08a25cc10df8112161f7180b3bbb4d662aadb711568602f9eddee54f0 + languageName: node + linkType: hard + +"universalify@npm:^0.1.0": + version: 0.1.2 + resolution: "universalify@npm:0.1.2" + checksum: 10/40cdc60f6e61070fe658ca36016a8f4ec216b29bf04a55dce14e3710cc84c7448538ef4dad3728d0bfe29975ccd7bfb5f414c45e7b78883567fb31b246f02dff + languageName: node + linkType: hard + +"which@npm:^2.0.1": + version: 2.0.2 + resolution: "which@npm:2.0.2" + dependencies: + isexe: "npm:^2.0.0" + bin: + node-which: ./bin/node-which + checksum: 10/4782f8a1d6b8fc12c65e968fea49f59752bf6302dc43036c3bf87da718a80710f61a062516e9764c70008b487929a73546125570acea95c5b5dcc8ac3052c70f + languageName: node + linkType: hard + +"which@npm:^4.0.0": + version: 4.0.0 + resolution: "which@npm:4.0.0" + dependencies: + isexe: "npm:^3.1.1" + bin: + node-which: bin/which.js + checksum: 10/f17e84c042592c21e23c8195108cff18c64050b9efb8459589116999ea9da6dd1509e6a1bac3aeebefd137be00fabbb61b5c2bc0aa0f8526f32b58ee2f545651 + languageName: node + linkType: hard + +"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0": + version: 7.0.0 + resolution: "wrap-ansi@npm:7.0.0" + dependencies: + ansi-styles: "npm:^4.0.0" + string-width: "npm:^4.1.0" + strip-ansi: "npm:^6.0.0" + checksum: 10/cebdaeca3a6880da410f75209e68cd05428580de5ad24535f22696d7d9cab134d1f8498599f344c3cf0fb37c1715807a183778d8c648d6cc0cb5ff2bb4236540 + languageName: node + linkType: hard + +"wrap-ansi@npm:^8.1.0": + version: 8.1.0 + resolution: "wrap-ansi@npm:8.1.0" + dependencies: + ansi-styles: "npm:^6.1.0" + string-width: "npm:^5.0.1" + strip-ansi: "npm:^7.0.1" + checksum: 10/7b1e4b35e9bb2312d2ee9ee7dc95b8cb5f8b4b5a89f7dde5543fe66c1e3715663094defa50d75454ac900bd210f702d575f15f3f17fa9ec0291806d2578d1ddf + languageName: node + linkType: hard + +"wrappy@npm:1": + version: 1.0.2 + resolution: "wrappy@npm:1.0.2" + checksum: 10/159da4805f7e84a3d003d8841557196034155008f817172d4e986bd591f74aa82aa7db55929a54222309e01079a65a92a9e6414da5a6aa4b01ee44a511ac3ee5 + languageName: node + linkType: hard + +"yallist@npm:^4.0.0": + version: 4.0.0 + resolution: "yallist@npm:4.0.0" + checksum: 10/4cb02b42b8a93b5cf50caf5d8e9beb409400a8a4d85e83bb0685c1457e9ac0b7a00819e9f5991ac25ffabb56a78e2f017c1acc010b3a1babfe6de690ba531abd + languageName: node + linkType: hard From 365c96fefc352d8ec3a959f73907b8d137847f3a Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Mon, 22 Jul 2024 17:29:31 -0400 Subject: [PATCH 08/28] non-OPFS/vfs connection works --- Cargo.lock | 98 ++++++++++++------------------- diesel-wasm-sqlite/Cargo.toml | 6 +- diesel-wasm-sqlite/package.js | 8 ++- diesel-wasm-sqlite/src/ffi.rs | 4 +- diesel-wasm-sqlite/src/lib.rs | 50 +++++++++------- diesel-wasm-sqlite/src/package.js | 12 ++-- diesel-wasm-sqlite/tests/web.rs | 23 +++----- 7 files changed, 93 insertions(+), 108 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index d77d862ef..0c61c6615 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -43,7 +43,7 @@ version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "cipher", "cpufeatures", ] @@ -326,7 +326,7 @@ checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a" dependencies = [ "addr2line", "cc", - "cfg-if 1.0.0", + "cfg-if", "libc", "miniz_oxide", "object", @@ -547,12 +547,6 @@ dependencies = [ "libc", ] -[[package]] -name = "cfg-if" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" - [[package]] name = "cfg-if" version = "1.0.0" @@ -565,7 +559,7 @@ version = "0.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "cipher", "cpufeatures", ] @@ -762,7 +756,7 @@ version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "wasm-bindgen", ] @@ -772,7 +766,7 @@ version = "1.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94fb8a24a26d37e1ffd45343323dc9fe6654ceea44c12f2fcb3d7ac29e610bc6" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "cpufeatures", "hex", "proptest", @@ -822,7 +816,7 @@ version = "1.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", ] [[package]] @@ -964,7 +958,7 @@ version = "4.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "cpufeatures", "curve25519-dalek-derive", "digest 0.10.7", @@ -1084,13 +1078,15 @@ version = "0.1.1" dependencies = [ "console_error_panic_hook", "diesel", + "futures", "getrandom", "log", "rand", + "tokio", "wasm-bindgen", + "wasm-bindgen-futures", "wasm-bindgen-test", "web-sys", - "wee_alloc", ] [[package]] @@ -1165,7 +1161,7 @@ version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "dirs-sys-next", ] @@ -1338,7 +1334,7 @@ version = "0.8.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", ] [[package]] @@ -1691,7 +1687,7 @@ version = "2.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "66244a771d9163282646dbeffe0e6eca4dda4146b6498644e678ac6089b11edd" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "const-hex", "dirs", "dunce", @@ -1745,7 +1741,7 @@ version = "2.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cc04871e5ae3aa2952d552dae6b291b3099723bf779a8054281c1366a54613ef" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "js-sys", "log", "serde", @@ -2032,7 +2028,7 @@ version = "0.2.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "js-sys", "libc", "wasi", @@ -2139,7 +2135,7 @@ version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "crunchy", ] @@ -2631,7 +2627,7 @@ version = "0.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "js-sys", "wasm-bindgen", "web-sys", @@ -2740,7 +2736,7 @@ version = "0.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92a55e0ff3b72c262bcf041d9e97f1b84492b68f1c1a384de2323d3dc9403397" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "ecdsa 0.15.1", "elliptic-curve 0.12.3", "once_cell", @@ -2754,7 +2750,7 @@ version = "0.13.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "956ff9b67e26e1a6a866cb758f12c6f8746208489e3e4a4b5580802f2f0a587b" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "ecdsa 0.16.9", "elliptic-curve 0.13.8", "once_cell", @@ -2945,7 +2941,7 @@ version = "0.10.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "digest 0.10.7", ] @@ -2955,12 +2951,6 @@ version = "2.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" -[[package]] -name = "memory_units" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8452105ba047068f40ff7093dd1d9da90898e63dd61736462e9cdda6a90ad3c3" - [[package]] name = "migrations_internals" version = "2.2.0" @@ -3051,7 +3041,7 @@ version = "0.11.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4c84490118f2ee2d74570d114f3d0493cbf02790df303d2707606c3e14e07c96" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "downcast", "fragile", "lazy_static", @@ -3066,7 +3056,7 @@ version = "0.11.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "22ce75669015c4f47b289fd4d4f56e894e4c96003ffdf3ac51313126f94c6cbb" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "proc-macro2", "quote", "syn 1.0.109", @@ -3398,7 +3388,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f" dependencies = [ "bitflags 2.6.0", - "cfg-if 1.0.0", + "cfg-if", "foreign-types", "libc", "once_cell", @@ -3532,7 +3522,7 @@ version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "60a2cfe6f0ad2bfc16aefa463b497d5c7a5ecd44a23efa72aa342d90177356dc" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "instant", "libc", "redox_syscall 0.2.16", @@ -3546,7 +3536,7 @@ version = "0.9.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "libc", "redox_syscall 0.5.3", "smallvec", @@ -3864,7 +3854,7 @@ version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "cpufeatures", "opaque-debug", "universal-hash", @@ -4395,7 +4385,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d" dependencies = [ "cc", - "cfg-if 1.0.0", + "cfg-if", "getrandom", "libc", "spin 0.9.8", @@ -4452,7 +4442,7 @@ version = "0.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "290ca1a1c8ca7edb7c3283bd44dc35dd54fdec6253a3912e201ba1072018fca8" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "proc-macro2", "quote", "rustc_version", @@ -4650,7 +4640,7 @@ version = "2.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eca070c12893629e2cc820a9761bedf6ce1dcddc9852984d1dc734b8bd9bd024" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "derive_more", "parity-scale-codec", "scale-info-derive", @@ -4859,7 +4849,7 @@ version = "0.10.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "cpufeatures", "digest 0.10.7", ] @@ -4871,7 +4861,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800" dependencies = [ "block-buffer 0.9.0", - "cfg-if 1.0.0", + "cfg-if", "cpufeatures", "digest 0.9.0", "opaque-debug", @@ -4883,7 +4873,7 @@ version = "0.10.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "cpufeatures", "digest 0.10.7", ] @@ -5253,7 +5243,7 @@ version = "3.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "fastrand", "rustix", "windows-sys 0.52.0", @@ -5311,7 +5301,7 @@ version = "1.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "once_cell", ] @@ -6074,7 +6064,7 @@ version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "serde", "serde_json", "wasm-bindgen-macro", @@ -6101,7 +6091,7 @@ version = "0.4.42" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "js-sys", "wasm-bindgen", "web-sys", @@ -6208,18 +6198,6 @@ dependencies = [ "rustls-pki-types", ] -[[package]] -name = "wee_alloc" -version = "0.4.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbb3b5a6b2bb17cb6ad44a2e68a43e8d2722c997da10e928665c72ec6c0a0b8e" -dependencies = [ - "cfg-if 0.1.10", - "libc", - "memory_units", - "winapi", -] - [[package]] name = "which" version = "4.4.2" @@ -6435,7 +6413,7 @@ version = "0.50.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "windows-sys 0.48.0", ] @@ -6445,7 +6423,7 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a277a57398d4bfa075df44f501a17cfdf8542d224f0d36095a2adc7aee4ef0a5" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "windows-sys 0.48.0", ] diff --git a/diesel-wasm-sqlite/Cargo.toml b/diesel-wasm-sqlite/Cargo.toml index 48ccd0ccd..b36563673 100644 --- a/diesel-wasm-sqlite/Cargo.toml +++ b/diesel-wasm-sqlite/Cargo.toml @@ -6,11 +6,15 @@ edition = "2021" [dependencies] diesel = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend", features = ["r2d2", "i-implement-a-third-party-backend-and-opt-into-breaking-changes"] } wasm-bindgen = "0.2" +wasm-bindgen-futures = "0.4" log = "0.4" rand = "0.8" getrandom = { version = "0.2", features = ["js"] } -wee_alloc = { version = "0.4.2", optional = true } +web-sys = { version = "0.3", features = ["console"] } +# wee_alloc = { version = "0.4.2", optional = true } console_error_panic_hook = { version = "0.1", optional = true } +tokio = { version = "1.38", default-features = false, features = ["rt", "macros", "sync", "io-util", "time"] } +futures = "0.3" [dev-dependencies] rand = "0.8" diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index 42a0603ba..01bd4507b 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -28,10 +28,12 @@ export function sqlite3_result_null(context) { sqlite3.result_null(context); } -export function establish(database_url) { +export async function establish(database_url) { try { - console.log("Opening database!"); - return sqlite3.open_v2(database_url); + console.log("Opening database!", database_url); + let db = await sqlite3.open_v2(database_url); + console.log(db); + return db; } catch { console.log("establish err"); } diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index d6db1dad1..be6edffd0 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -4,10 +4,10 @@ use wasm_bindgen::{prelude::*, JsValue}; #[wasm_bindgen(module = "/src/package.js")] extern "C" { #[wasm_bindgen(catch)] - pub fn batch_execute(database: i32, query: &str) -> Result<(), JsValue>; + pub fn batch_execute(database: &JsValue, query: &str) -> Result<(), JsValue>; #[wasm_bindgen(catch)] - pub fn establish(database_url: &str) -> Result; + pub async fn establish(database_url: &str) -> Result; } /// Direct Shim for wa-sqlite diff --git a/diesel-wasm-sqlite/src/lib.rs b/diesel-wasm-sqlite/src/lib.rs index 668c8ea8e..d8add46ae 100644 --- a/diesel-wasm-sqlite/src/lib.rs +++ b/diesel-wasm-sqlite/src/lib.rs @@ -18,7 +18,7 @@ pub use backend::{SqliteType, WasmSqlite}; #[derive(Debug)] pub struct WasmSqliteConnection { - raw_db_pointer: i32, + raw_db_pointer: JsValue, } #[derive(Debug)] @@ -26,7 +26,7 @@ pub struct WasmSqliteError(JsValue); impl SimpleConnection for WasmSqliteConnection { fn batch_execute(&mut self, query: &str) -> diesel::prelude::QueryResult<()> { - ffi::batch_execute(self.raw_db_pointer, query) + ffi::batch_execute(&self.raw_db_pointer, query) .map_err(WasmSqliteError::from) .map_err(Into::into) } @@ -34,18 +34,37 @@ impl SimpleConnection for WasmSqliteConnection { impl diesel::connection::ConnectionSealed for WasmSqliteConnection {} +pub async fn rust_establish( + database_url: &str, +) -> diesel::prelude::ConnectionResult { + let raw_conn = ffi::establish(database_url) + .await + .map_err(WasmSqliteError::from) + .map_err(Into::::into)?; + web_sys::console::log_1(&format!("raw conn: {:?}", raw_conn).into()); + Ok(WasmSqliteConnection { + raw_db_pointer: raw_conn, + }) +} + +unsafe impl Send for WasmSqliteConnection {} impl Connection for WasmSqliteConnection { type Backend = WasmSqlite; type TransactionManager = AnsiTransactionManager; - fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { - let raw_conn = ffi::establish(database_url) - .map_err(WasmSqliteError::from) - .map_err(Into::::into)?; - Ok(WasmSqliteConnection { - raw_db_pointer: raw_conn, - }) + todo!(); } + /* + fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { + let raw_conn = ffi::establish(database_url) + .map_err(WasmSqliteError::from) + .map_err(Into::::into)?; + web_sys::console::log_1(&format!("raw conn: {:?}", raw_conn).into()); + Ok(WasmSqliteConnection { + raw_db_pointer: raw_conn, + }) + } + */ fn execute_returning_count(&mut self, source: &T) -> QueryResult where @@ -69,18 +88,6 @@ impl Connection for WasmSqliteConnection { } } -#[wasm_bindgen(js_name = establishDbConnection)] -pub fn establish_db_connection() { - let rng: u16 = rand::random(); - let url = format!( - "{}/wasmtest-{}.db3", - std::env::temp_dir().to_str().unwrap(), - rng - ); - let conn = WasmSqliteConnection::establish(&url).unwrap(); - println!("{:?}", conn); -} - impl From for diesel::result::Error { fn from(value: WasmSqliteError) -> diesel::result::Error { log::error!("NOT IMPLEMENTED, {:?}", value); @@ -91,6 +98,7 @@ impl From for diesel::result::Error { impl From for diesel::result::ConnectionError { fn from(value: WasmSqliteError) -> diesel::result::ConnectionError { log::error!("NOT IMPLEMENTED, {:?}", value); + web_sys::console::log_1(&value.0); diesel::result::ConnectionError::BadConnection("Not implemented".to_string()) } } diff --git a/diesel-wasm-sqlite/src/package.js b/diesel-wasm-sqlite/src/package.js index d8cedc13a..aea9ac18f 100644 --- a/diesel-wasm-sqlite/src/package.js +++ b/diesel-wasm-sqlite/src/package.js @@ -898,12 +898,8 @@ var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;var readyPromise ); })(); -// import { OPFSCoopSyncVFS } from "@xmtp/wa-sqlite/vfs/OPFSCoopSync"; - const module = await Module(); const sqlite3 = Factory(module); -// const vfs = await OPFSCoopSyncVFS.create("test", module); -// sqlite3.vfs_register(vfs, true); function sqlite3_result_text(context, value) { sqlite3.result_text(context, value); @@ -929,10 +925,12 @@ function sqlite3_result_null(context) { sqlite3.result_null(context); } -function establish(database_url) { +async function establish(database_url) { try { - console.log("Opening database!"); - return sqlite3.open_v2(database_url); + console.log("Opening database!", database_url); + let db = await sqlite3.open_v2(database_url); + console.log(db); + return db; } catch { console.log("establish err"); } diff --git a/diesel-wasm-sqlite/tests/web.rs b/diesel-wasm-sqlite/tests/web.rs index 58a99584a..02e52bc53 100755 --- a/diesel-wasm-sqlite/tests/web.rs +++ b/diesel-wasm-sqlite/tests/web.rs @@ -1,27 +1,22 @@ #![cfg(target_arch = "wasm32")] -use diesel_wasm_sqlite::WasmSqliteConnection; +use diesel::connection::Connection; +use diesel_wasm_sqlite::rust_establish; use wasm_bindgen_test::*; use web_sys::console; wasm_bindgen_test_configure!(run_in_browser); #[wasm_bindgen_test] -fn test_console_log() { - diesel_wasm_sqlite::utils::set_panic_hook(); - console::log_1(&"TEST THIS WORKS????".into()); - assert_eq!(1, 2); -} - -/* -#[wasm_bindgen_test] -fn test_establish() { +async fn test_establish() { let rng: u16 = rand::random(); - let url = format!( + /* let url = format!( "{}/wasmtest-{}.db3", std::env::temp_dir().to_str().unwrap(), rng ); - let mut conn = WasmSqliteConnection::establish(&url).unwrap(); - println!("{:?}", conn); + */ + let mut conn = rust_establish("test").await.unwrap(); + console::log_1(&"CONNECTED".into()); + // assert 1 == 2 is here b/c can't get --nocapture to work yet + assert_eq!(1, 2); } -*/ From c7a3731579e25c2ae79f30dd7b1c2828bdb5853b Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Tue, 23 Jul 2024 14:15:46 -0400 Subject: [PATCH 09/28] embed wasm in rollup JS and pass it to module instantiation --- diesel-wasm-sqlite/Cargo.toml | 6 ++--- diesel-wasm-sqlite/README.md | 10 ++++++-- diesel-wasm-sqlite/build.rs | 22 ++++++++++++++++ diesel-wasm-sqlite/package.js | 21 ++++++++++++++-- diesel-wasm-sqlite/package.json | 1 + diesel-wasm-sqlite/rollup.config.js | 11 ++------ diesel-wasm-sqlite/src/package.js | 20 ++++++++++++++- diesel-wasm-sqlite/yarn.lock | 39 ++++++++++++++++++++++++++++- 8 files changed, 112 insertions(+), 18 deletions(-) create mode 100644 diesel-wasm-sqlite/build.rs diff --git a/diesel-wasm-sqlite/Cargo.toml b/diesel-wasm-sqlite/Cargo.toml index b36563673..2afb4e20d 100644 --- a/diesel-wasm-sqlite/Cargo.toml +++ b/diesel-wasm-sqlite/Cargo.toml @@ -5,8 +5,8 @@ edition = "2021" [dependencies] diesel = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend", features = ["r2d2", "i-implement-a-third-party-backend-and-opt-into-breaking-changes"] } -wasm-bindgen = "0.2" -wasm-bindgen-futures = "0.4" +wasm-bindgen = "0.2.92" +wasm-bindgen-futures = "0.4.42" log = "0.4" rand = "0.8" getrandom = { version = "0.2", features = ["js"] } @@ -19,7 +19,7 @@ futures = "0.3" [dev-dependencies] rand = "0.8" getrandom = { version = "0.2", features = ["js"] } -wasm-bindgen-test = "0.3" +wasm-bindgen-test = "0.3.42" web-sys = { version = "0.3", features = ["console"] } diff --git a/diesel-wasm-sqlite/README.md b/diesel-wasm-sqlite/README.md index 57e36feb7..608cdda29 100644 --- a/diesel-wasm-sqlite/README.md +++ b/diesel-wasm-sqlite/README.md @@ -2,7 +2,7 @@ #### Bundle the javascript in `package.js` to rust -`npm run esbuild` +`yarn run build` #### Build the JS WASM interface @@ -10,4 +10,10 @@ #### Run the Wasm Tests -wasm-pack test --safari --headless +wasm-pack test --chrome --headless + +# TODO + +- [ ] wa-sqlite should be included in `pkg` build w/o manual copy (wasm-pack + issue?) +- [ ] OPFS diff --git a/diesel-wasm-sqlite/build.rs b/diesel-wasm-sqlite/build.rs new file mode 100644 index 000000000..22414d535 --- /dev/null +++ b/diesel-wasm-sqlite/build.rs @@ -0,0 +1,22 @@ +use std::env; +use std::process::Command; + +fn main() { + // Tell Cargo that if the given file changes, to rerun this build script. + println!("cargo::rerun-if-changed=package.js"); + // println!("cargo::rerun-if-changed=package.js"); + // can run yarn run build here too + // let out_dir = env::var("OUT_DIR").unwrap(); + + Command::new("yarn") + .args(["run", "build"]) + .status() + .unwrap(); + /* + Command::new("cp") + .args(["src/wa-sqlite.wasm"]) + .arg(&format!("{}/wa-sqlite.wasm", out_dir)) + .status() + .unwrap(); + */ +} diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index 01bd4507b..a13b5fe49 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -1,7 +1,24 @@ import * as SQLite from "@xmtp/wa-sqlite"; -import initModule from "@xmtp/wa-sqlite/build"; +import SQLiteESMFactory from "./node_modules/@xmtp/wa-sqlite/dist/wa-sqlite.mjs"; +import base64Wasm from "./node_modules/@xmtp/wa-sqlite/dist/wa-sqlite.wasm"; -const module = await initModule(); +function base64Decode(str) { + const binaryString = typeof atob === "function" + ? atob(str) + : Buffer.from(str, "base64").toString("binary"); + const len = binaryString.length; + const bytes = new Uint8Array(len); + for (let i = 0; i < len; i++) { + bytes[i] = binaryString.charCodeAt(i); + } + return bytes.buffer; +} + +const module = await SQLiteESMFactory({ + "wasmBinary": base64Decode(base64Wasm), +}); + +// const module = await initWasmModule(); const sqlite3 = SQLite.Factory(module); export function sqlite3_result_text(context, value) { diff --git a/diesel-wasm-sqlite/package.json b/diesel-wasm-sqlite/package.json index 7fee0b676..6f529c83e 100644 --- a/diesel-wasm-sqlite/package.json +++ b/diesel-wasm-sqlite/package.json @@ -17,6 +17,7 @@ "devDependencies": { "@rollup/plugin-node-resolve": "^15.2.3", "rollup": "^4.19.0", + "rollup-plugin-base64": "^1.0.1", "rollup-plugin-copy": "^3.5.0" } } diff --git a/diesel-wasm-sqlite/rollup.config.js b/diesel-wasm-sqlite/rollup.config.js index a2ceba45a..5cb7854ff 100644 --- a/diesel-wasm-sqlite/rollup.config.js +++ b/diesel-wasm-sqlite/rollup.config.js @@ -1,6 +1,6 @@ import { defineConfig } from "rollup"; import resolve from "@rollup/plugin-node-resolve"; -import copy from "rollup-plugin-copy"; +import { base64 } from "rollup-plugin-base64"; export default defineConfig([ { @@ -11,14 +11,7 @@ export default defineConfig([ }, plugins: [ resolve(), - copy({ - targets: [ - { - src: "node_modules/@xmtp/wa-sqlite/dist/wa-sqlite.wasm", - dest: "src", - }, - ], - }), + base64({ include: "**/*.wasm" }), ], // external: ["@xmtp/wa-sqlite", "@xmtp/wa-sqlite/build"], }, diff --git a/diesel-wasm-sqlite/src/package.js b/diesel-wasm-sqlite/src/package.js index aea9ac18f..649b64a76 100644 --- a/diesel-wasm-sqlite/src/package.js +++ b/diesel-wasm-sqlite/src/package.js @@ -898,7 +898,25 @@ var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;var readyPromise ); })(); -const module = await Module(); +var base64Wasm = "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"; + +function base64Decode(str) { + const binaryString = typeof atob === "function" + ? atob(str) + : Buffer.from(str, "base64").toString("binary"); + const len = binaryString.length; + const bytes = new Uint8Array(len); + for (let i = 0; i < len; i++) { + bytes[i] = binaryString.charCodeAt(i); + } + return bytes.buffer; +} + +const module = await Module({ + "wasmBinary": base64Decode(base64Wasm), +}); + +// const module = await initWasmModule(); const sqlite3 = Factory(module); function sqlite3_result_text(context, value) { diff --git a/diesel-wasm-sqlite/yarn.lock b/diesel-wasm-sqlite/yarn.lock index 8167a26ed..59311254a 100644 --- a/diesel-wasm-sqlite/yarn.lock +++ b/diesel-wasm-sqlite/yarn.lock @@ -94,6 +94,19 @@ __metadata: languageName: node linkType: hard +"@rollup/pluginutils@npm:^3.1.0": + version: 3.1.0 + resolution: "@rollup/pluginutils@npm:3.1.0" + dependencies: + "@types/estree": "npm:0.0.39" + estree-walker: "npm:^1.0.1" + picomatch: "npm:^2.2.2" + peerDependencies: + rollup: ^1.20.0||^2.0.0 + checksum: 10/3b69f02893eea42455fb97b81f612ac6bfadf94ac73bebd481ea13e90a693eef52c163210a095b12e574a25603af5e55f86a020889019167f331aa8dd3ff30e0 + languageName: node + linkType: hard + "@rollup/pluginutils@npm:^5.0.1": version: 5.1.0 resolution: "@rollup/pluginutils@npm:5.1.0" @@ -222,6 +235,13 @@ __metadata: languageName: node linkType: hard +"@types/estree@npm:0.0.39": + version: 0.0.39 + resolution: "@types/estree@npm:0.0.39" + checksum: 10/9f0f20990dbf725470564d4d815d3758ac688b790f601ea98654b6e0b9797dc3c80306fb525abdacd9e75e014e3d09ad326098eaa2ed1851e4823a8e278538aa + languageName: node + linkType: hard + "@types/estree@npm:1.0.5, @types/estree@npm:^1.0.0": version: 1.0.5 resolution: "@types/estree@npm:1.0.5" @@ -489,6 +509,7 @@ __metadata: "@rollup/plugin-node-resolve": "npm:^15.2.3" "@xmtp/wa-sqlite": "npm:^1.0.1" rollup: "npm:^4.19.0" + rollup-plugin-base64: "npm:^1.0.1" rollup-plugin-copy: "npm:^3.5.0" languageName: unknown linkType: soft @@ -546,6 +567,13 @@ __metadata: languageName: node linkType: hard +"estree-walker@npm:^1.0.1": + version: 1.0.1 + resolution: "estree-walker@npm:1.0.1" + checksum: 10/1cf11a0aff7613aa765dc535ed1d83e2a1986207d2353f4795df309a2c55726de3ca4948df635c09969a739dc59e8e2d69f88d3b3d2c6dfc5701257aafd1d11b + languageName: node + linkType: hard + "estree-walker@npm:^2.0.2": version: 2.0.2 resolution: "estree-walker@npm:2.0.2" @@ -1196,7 +1224,7 @@ __metadata: languageName: node linkType: hard -"picomatch@npm:^2.3.1": +"picomatch@npm:^2.2.2, picomatch@npm:^2.3.1": version: 2.3.1 resolution: "picomatch@npm:2.3.1" checksum: 10/60c2595003b05e4535394d1da94850f5372c9427ca4413b71210f437f7b2ca091dbd611c45e8b37d10036fa8eade25c1b8951654f9d3973bfa66a2ff4d3b08bc @@ -1267,6 +1295,15 @@ __metadata: languageName: node linkType: hard +"rollup-plugin-base64@npm:^1.0.1": + version: 1.0.1 + resolution: "rollup-plugin-base64@npm:1.0.1" + dependencies: + "@rollup/pluginutils": "npm:^3.1.0" + checksum: 10/1f4ebf46a9ec5220ba9b596820e56d6a7a1b77d567097b8713a63ef669b02b1d296d6e77f48c01e43de7c98c751b5ee5683b4b1f7e4cb4b76a4fe55109654862 + languageName: node + linkType: hard + "rollup-plugin-copy@npm:^3.5.0": version: 3.5.0 resolution: "rollup-plugin-copy@npm:3.5.0" From d145da62de0243f6fea62082977b032ce32a9715 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Wed, 24 Jul 2024 21:49:05 -0400 Subject: [PATCH 10/28] add connection files, compile a few fns in raw connection --- Cargo.lock | 81 ++- diesel-wasm-sqlite/Cargo.toml | 7 +- diesel-wasm-sqlite/build.rs | 17 +- diesel-wasm-sqlite/package.js | 107 +-- diesel-wasm-sqlite/src/connection.rs | 2 - .../src/connection/bind_collector.rs | 22 +- .../connection/diesel_manage_updated_at.sql | 11 + .../src/connection/functions.rs | 253 +++++++ diesel-wasm-sqlite/src/connection/mod.rs | 636 ++++++++++++++++++ .../src/connection/owned_row.rs | 92 +++ diesel-wasm-sqlite/src/connection/raw.rs | 606 +++++++++++++++++ diesel-wasm-sqlite/src/connection/row.rs | 408 +++++++++++ .../src/connection/serialized_database.rs | 45 ++ .../src/connection/sqlite_value.rs | 172 +++++ .../src/connection/statement_iterator.rs | 172 +++++ diesel-wasm-sqlite/src/connection/stmt.rs | 540 +++++++++++++++ diesel-wasm-sqlite/src/ffi.rs | 63 +- diesel-wasm-sqlite/src/lib.rs | 111 +-- diesel-wasm-sqlite/src/package.js | 602 +++++++++++++++-- .../src/query_builder/returning.rs | 4 +- diesel-wasm-sqlite/src/sqlite_types.rs | 28 + diesel-wasm-sqlite/tests/web.rs | 2 +- 22 files changed, 3765 insertions(+), 216 deletions(-) delete mode 100644 diesel-wasm-sqlite/src/connection.rs create mode 100644 diesel-wasm-sqlite/src/connection/diesel_manage_updated_at.sql create mode 100644 diesel-wasm-sqlite/src/connection/functions.rs create mode 100644 diesel-wasm-sqlite/src/connection/mod.rs create mode 100644 diesel-wasm-sqlite/src/connection/owned_row.rs create mode 100644 diesel-wasm-sqlite/src/connection/raw.rs create mode 100644 diesel-wasm-sqlite/src/connection/row.rs create mode 100644 diesel-wasm-sqlite/src/connection/serialized_database.rs create mode 100644 diesel-wasm-sqlite/src/connection/sqlite_value.rs create mode 100644 diesel-wasm-sqlite/src/connection/statement_iterator.rs create mode 100644 diesel-wasm-sqlite/src/connection/stmt.rs diff --git a/Cargo.lock b/Cargo.lock index 0c61c6615..c29df6d2e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1066,18 +1066,41 @@ name = "diesel" version = "2.2.0" source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ - "diesel_derives", + "diesel_derives 2.2.0", "libsqlite3-sys", "r2d2", "time", ] +[[package]] +name = "diesel" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf97ee7261bb708fa3402fa9c17a54b70e90e3cb98afb3dc8999d5512cb03f94" +dependencies = [ + "diesel_derives 2.2.2", +] + +[[package]] +name = "diesel-async" +version = "0.5.0" +source = "git+https://github.com/insipx/diesel_async?branch=insipx/wasm-async#c255cddfecec3597fb102cfa85494f6e23cb6b9b" +dependencies = [ + "async-trait", + "diesel 2.2.2", + "futures-util", + "scoped-futures", +] + [[package]] name = "diesel-wasm-sqlite" version = "0.1.1" dependencies = [ + "async-trait", + "bitflags 2.6.0", "console_error_panic_hook", - "diesel", + "diesel 2.2.2", + "diesel-async", "futures", "getrandom", "log", @@ -1094,8 +1117,21 @@ name = "diesel_derives" version = "2.2.0" source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ - "diesel_table_macro_syntax", - "dsl_auto_type", + "diesel_table_macro_syntax 0.2.0 (git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend)", + "dsl_auto_type 0.1.0", + "proc-macro2", + "quote", + "syn 2.0.71", +] + +[[package]] +name = "diesel_derives" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6ff2be1e7312c858b2ef974f5c7089833ae57b5311b334b30923af58e5718d8" +dependencies = [ + "diesel_table_macro_syntax 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", + "dsl_auto_type 0.1.2", "proc-macro2", "quote", "syn 2.0.71", @@ -1106,11 +1142,20 @@ name = "diesel_migrations" version = "2.2.0" source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ - "diesel", + "diesel 2.2.0", "migrations_internals", "migrations_macros", ] +[[package]] +name = "diesel_table_macro_syntax" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" +dependencies = [ + "syn 2.0.71", +] + [[package]] name = "diesel_table_macro_syntax" version = "0.2.0" @@ -1207,6 +1252,20 @@ dependencies = [ "syn 2.0.71", ] +[[package]] +name = "dsl_auto_type" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5d9abe6314103864cc2d8901b7ae224e0ab1a103a0a416661b4097b0779b607" +dependencies = [ + "darling", + "either", + "heck 0.5.0", + "proc-macro2", + "quote", + "syn 2.0.71", +] + [[package]] name = "dunce" version = "1.0.4" @@ -4676,6 +4735,16 @@ dependencies = [ "parking_lot 0.12.3", ] +[[package]] +name = "scoped-futures" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1473e24c637950c9bd38763220bea91ec3e095a89f672bbd7a10d03e77ba467" +dependencies = [ + "cfg-if", + "pin-utils", +] + [[package]] name = "scoped-tls" version = "1.0.1" @@ -6584,7 +6653,7 @@ dependencies = [ "chrono", "criterion", "ctor", - "diesel", + "diesel 2.2.0", "diesel_migrations", "ed25519-dalek", "ethers", diff --git a/diesel-wasm-sqlite/Cargo.toml b/diesel-wasm-sqlite/Cargo.toml index 2afb4e20d..ae566a745 100644 --- a/diesel-wasm-sqlite/Cargo.toml +++ b/diesel-wasm-sqlite/Cargo.toml @@ -4,7 +4,9 @@ version = "0.1.1" edition = "2021" [dependencies] -diesel = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend", features = ["r2d2", "i-implement-a-third-party-backend-and-opt-into-breaking-changes"] } +# diesel = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend", default-features = false, features = ["i-implement-a-third-party-backend-and-opt-into-breaking-changes"] } +diesel = "2.2" +diesel-async = { git = "https://github.com/insipx/diesel_async", branch = "insipx/wasm-async" } wasm-bindgen = "0.2.92" wasm-bindgen-futures = "0.4.42" log = "0.4" @@ -15,6 +17,8 @@ web-sys = { version = "0.3", features = ["console"] } console_error_panic_hook = { version = "0.1", optional = true } tokio = { version = "1.38", default-features = false, features = ["rt", "macros", "sync", "io-util", "time"] } futures = "0.3" +async-trait = "0.1" +bitflags = "2.6" [dev-dependencies] rand = "0.8" @@ -28,3 +32,4 @@ crate-type = ["cdylib", "rlib"] [features] default = ["console_error_panic_hook"] + diff --git a/diesel-wasm-sqlite/build.rs b/diesel-wasm-sqlite/build.rs index 22414d535..01bfc1044 100644 --- a/diesel-wasm-sqlite/build.rs +++ b/diesel-wasm-sqlite/build.rs @@ -2,21 +2,16 @@ use std::env; use std::process::Command; fn main() { - // Tell Cargo that if the given file changes, to rerun this build script. println!("cargo::rerun-if-changed=package.js"); - // println!("cargo::rerun-if-changed=package.js"); - // can run yarn run build here too - // let out_dir = env::var("OUT_DIR").unwrap(); Command::new("yarn") .args(["run", "build"]) .status() .unwrap(); - /* - Command::new("cp") - .args(["src/wa-sqlite.wasm"]) - .arg(&format!("{}/wa-sqlite.wasm", out_dir)) - .status() - .unwrap(); - */ + + let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap(); + if target_arch != "wasm32" { + // Emit a compile error if the target is not wasm32-unknown-unknown + panic!("This crate only supports the wasm32 architecture"); + } } diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index a13b5fe49..1d25c662d 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -1,4 +1,4 @@ -import * as SQLite from "@xmtp/wa-sqlite"; +import * as WasmSQLiteLibrary from "@xmtp/wa-sqlite"; import SQLiteESMFactory from "./node_modules/@xmtp/wa-sqlite/dist/wa-sqlite.mjs"; import base64Wasm from "./node_modules/@xmtp/wa-sqlite/dist/wa-sqlite.wasm"; @@ -14,53 +14,82 @@ function base64Decode(str) { return bytes.buffer; } -const module = await SQLiteESMFactory({ - "wasmBinary": base64Decode(base64Wasm), -}); +export class SQLite { + #module; + #sqlite3; + constructor(module) { + if (typeof module === "undefined") { + throw new Error("Cannot be called directly"); + } -// const module = await initWasmModule(); -const sqlite3 = SQLite.Factory(module); + this.sqlite3 = WasmSQLiteLibrary.Factory(module); + } -export function sqlite3_result_text(context, value) { - sqlite3.result_text(context, value); -} + static async wasm_module() { + return await SQLiteESMFactory({ + "wasmBinary": base64Decode(base64Wasm), + }); + } -export function sqlite3_result_int(context, value) { - sqlite3.result_int(context, value); -} + static async build() { + const module = await SQLiteESMFactory({ + "wasmBinary": base64Decode(base64Wasm), + }); + return new WasmSQLiteLibrary(module); + } -export function sqlite3_result_int64(context, value) { - sqlite3.result_int64(context, value); -} + result_text(context, value) { + this.sqlite3.result_text(context, value); + } -export function sqlite3_result_double(context, value) { - sqlite3.result_double(context, value); -} + result_int(context, value) { + this.sqlite3.result_int(context, value); + } -export function sqlite3_result_blob(context, value) { - sqlite3.result_blob(context, value); -} + result_int64(context, value) { + this.sqlite3.result_int64(context, value); + } -export function sqlite3_result_null(context) { - sqlite3.result_null(context); -} + result_double(context, value) { + this.sqlite3.result_double(context, value); + } -export async function establish(database_url) { - try { - console.log("Opening database!", database_url); - let db = await sqlite3.open_v2(database_url); - console.log(db); - return db; - } catch { - console.log("establish err"); + result_blob(context, value) { + this.sqlite3.result_blob(context, value); + } + + result_null(context) { + this.sqlite3.result_null(context); + } + + async open_v2(database_url, iflags) { + try { + console.log("Opening database!", database_url); + let db = await this.sqlite3.open_v2(database_url, iflags); + return db; + } catch { + console.log("openv2 error"); + } + } + + async exec(db, query) { + try { + return await this.sqlite3.exec(db, query); + } catch { + console.log('exec err'); + } + } + + changes(db) { + return this.sqlite3.changes(db); } -} -export function batch_execute(database, query) { - try { - sqlite3.exec(database, query); - console.log("Batch exec'ed"); - } catch { - console.log("exec err"); + batch_execute(database, query) { + try { + sqlite3.exec(database, query); + console.log("Batch exec'ed"); + } catch { + console.log("exec err"); + } } } diff --git a/diesel-wasm-sqlite/src/connection.rs b/diesel-wasm-sqlite/src/connection.rs deleted file mode 100644 index 3f31e1532..000000000 --- a/diesel-wasm-sqlite/src/connection.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub mod bind_collector; -pub use bind_collector::*; diff --git a/diesel-wasm-sqlite/src/connection/bind_collector.rs b/diesel-wasm-sqlite/src/connection/bind_collector.rs index 377647e03..3258aef9e 100644 --- a/diesel-wasm-sqlite/src/connection/bind_collector.rs +++ b/diesel-wasm-sqlite/src/connection/bind_collector.rs @@ -126,20 +126,16 @@ impl std::fmt::Display for InternalSqliteBindValue<'_> { impl InternalSqliteBindValue<'_> { #[allow(unsafe_code)] // ffi function calls pub(crate) fn result_of(self, ctx: &mut i32) { - use crate::ffi; + let sqlite3 = crate::get_sqlite_unchecked(); match self { - InternalSqliteBindValue::BorrowedString(s) => { - ffi::sqlite3_result_text(*ctx, s.to_string()) - } - InternalSqliteBindValue::String(s) => ffi::sqlite3_result_text(*ctx, s.to_string()), - InternalSqliteBindValue::Binary(b) => ffi::sqlite3_result_blob(*ctx, b.to_vec()), - InternalSqliteBindValue::BorrowedBinary(b) => { - ffi::sqlite3_result_blob(*ctx, b.to_vec()) - } - InternalSqliteBindValue::I32(i) => ffi::sqlite3_result_int(*ctx, i), - InternalSqliteBindValue::I64(l) => ffi::sqlite3_result_int64(*ctx, l), - InternalSqliteBindValue::F64(d) => ffi::sqlite3_result_double(*ctx, d), - InternalSqliteBindValue::Null => ffi::sqlite3_result_null(*ctx), + InternalSqliteBindValue::BorrowedString(s) => sqlite3.result_text(*ctx, s.to_string()), + InternalSqliteBindValue::String(s) => sqlite3.result_text(*ctx, s.to_string()), + InternalSqliteBindValue::Binary(b) => sqlite3.result_blob(*ctx, b.to_vec()), + InternalSqliteBindValue::BorrowedBinary(b) => sqlite3.result_blob(*ctx, b.to_vec()), + InternalSqliteBindValue::I32(i) => sqlite3.result_int(*ctx, i), + InternalSqliteBindValue::I64(l) => sqlite3.result_int64(*ctx, l), + InternalSqliteBindValue::F64(d) => sqlite3.result_double(*ctx, d), + InternalSqliteBindValue::Null => sqlite3.result_null(*ctx), } } } diff --git a/diesel-wasm-sqlite/src/connection/diesel_manage_updated_at.sql b/diesel-wasm-sqlite/src/connection/diesel_manage_updated_at.sql new file mode 100644 index 000000000..83c3d33d4 --- /dev/null +++ b/diesel-wasm-sqlite/src/connection/diesel_manage_updated_at.sql @@ -0,0 +1,11 @@ +CREATE TRIGGER __diesel_manage_updated_at_{table_name} +AFTER UPDATE ON {table_name} +FOR EACH ROW WHEN + old.updated_at IS NULL AND + new.updated_at IS NULL OR + old.updated_at == new.updated_at +BEGIN + UPDATE {table_name} + SET updated_at = CURRENT_TIMESTAMP + WHERE ROWID = new.ROWID; +END diff --git a/diesel-wasm-sqlite/src/connection/functions.rs b/diesel-wasm-sqlite/src/connection/functions.rs new file mode 100644 index 000000000..db330ee23 --- /dev/null +++ b/diesel-wasm-sqlite/src/connection/functions.rs @@ -0,0 +1,253 @@ +extern crate libsqlite3_sys as ffi; + +use super::raw::RawConnection; +use super::row::PrivateSqliteRow; +use super::{Sqlite, SqliteAggregateFunction, SqliteBindValue}; +use crate::backend::Backend; +use crate::deserialize::{FromSqlRow, StaticallySizedRow}; +use crate::result::{DatabaseErrorKind, Error, QueryResult}; +use crate::row::{Field, PartialRow, Row, RowIndex, RowSealed}; +use crate::serialize::{IsNull, Output, ToSql}; +use crate::sql_types::HasSqlType; +use crate::sqlite::connection::bind_collector::InternalSqliteBindValue; +use crate::sqlite::connection::sqlite_value::OwnedSqliteValue; +use crate::sqlite::SqliteValue; +use std::cell::{Ref, RefCell}; +use std::marker::PhantomData; +use std::mem::ManuallyDrop; +use std::ops::DerefMut; +use std::rc::Rc; + +pub(super) fn register( + conn: &RawConnection, + fn_name: &str, + deterministic: bool, + mut f: F, +) -> QueryResult<()> +where + F: FnMut(&RawConnection, Args) -> Ret + std::panic::UnwindSafe + Send + 'static, + Args: FromSqlRow + StaticallySizedRow, + Ret: ToSql, + Sqlite: HasSqlType, +{ + let fields_needed = Args::FIELD_COUNT; + if fields_needed > 127 { + return Err(Error::DatabaseError( + DatabaseErrorKind::UnableToSendCommand, + Box::new("SQLite functions cannot take more than 127 parameters".to_string()), + )); + } + + conn.register_sql_function(fn_name, fields_needed, deterministic, move |conn, args| { + let args = build_sql_function_args::(args)?; + + Ok(f(conn, args)) + })?; + Ok(()) +} + +pub(super) fn register_noargs( + conn: &RawConnection, + fn_name: &str, + deterministic: bool, + mut f: F, +) -> QueryResult<()> +where + F: FnMut() -> Ret + std::panic::UnwindSafe + Send + 'static, + Ret: ToSql, + Sqlite: HasSqlType, +{ + conn.register_sql_function(fn_name, 0, deterministic, move |_, _| Ok(f()))?; + Ok(()) +} + +pub(super) fn register_aggregate( + conn: &RawConnection, + fn_name: &str, +) -> QueryResult<()> +where + A: SqliteAggregateFunction + 'static + Send + std::panic::UnwindSafe, + Args: FromSqlRow + StaticallySizedRow, + Ret: ToSql, + Sqlite: HasSqlType, +{ + let fields_needed = Args::FIELD_COUNT; + if fields_needed > 127 { + return Err(Error::DatabaseError( + DatabaseErrorKind::UnableToSendCommand, + Box::new("SQLite functions cannot take more than 127 parameters".to_string()), + )); + } + + conn.register_aggregate_function::( + fn_name, + fields_needed, + )?; + + Ok(()) +} + +pub(super) fn build_sql_function_args( + args: &mut [*mut ffi::sqlite3_value], +) -> Result +where + Args: FromSqlRow, +{ + let row = FunctionRow::new(args); + Args::build_from_row(&row).map_err(Error::DeserializationError) +} + +// clippy is wrong here, the let binding is required +// for lifetime reasons +#[allow(clippy::let_unit_value)] +pub(super) fn process_sql_function_result( + result: &'_ Ret, +) -> QueryResult> +where + Ret: ToSql, + Sqlite: HasSqlType, +{ + let mut metadata_lookup = (); + let value = SqliteBindValue { + inner: InternalSqliteBindValue::Null, + }; + let mut buf = Output::new(value, &mut metadata_lookup); + let is_null = result.to_sql(&mut buf).map_err(Error::SerializationError)?; + + if let IsNull::Yes = is_null { + Ok(InternalSqliteBindValue::Null) + } else { + Ok(buf.into_inner().inner) + } +} + +struct FunctionRow<'a> { + // we use `ManuallyDrop` to prevent dropping the content of the internal vector + // as this buffer is owned by sqlite not by diesel + args: Rc>>>, + field_count: usize, + marker: PhantomData<&'a ffi::sqlite3_value>, +} + +impl<'a> Drop for FunctionRow<'a> { + #[allow(unsafe_code)] // manual drop calls + fn drop(&mut self) { + if let Some(args) = Rc::get_mut(&mut self.args) { + if let PrivateSqliteRow::Duplicated { column_names, .. } = + DerefMut::deref_mut(RefCell::get_mut(args)) + { + if Rc::strong_count(column_names) == 1 { + // According the https://doc.rust-lang.org/std/mem/struct.ManuallyDrop.html#method.drop + // it's fine to just drop the values here + unsafe { std::ptr::drop_in_place(column_names as *mut _) } + } + } + } + } +} + +impl<'a> FunctionRow<'a> { + #[allow(unsafe_code)] // complicated ptr cast + fn new(args: &mut [*mut ffi::sqlite3_value]) -> Self { + let lengths = args.len(); + let args = unsafe { + Vec::from_raw_parts( + // This cast is safe because: + // * Casting from a pointer to an array to a pointer to the first array + // element is safe + // * Casting from a raw pointer to `NonNull` is safe, + // because `NonNull` is #[repr(transparent)] + // * Casting from `NonNull` to `OwnedSqliteValue` is safe, + // as the struct is `#[repr(transparent)] + // * Casting from `NonNull` to `Option>` as the documentation + // states: "This is so that enums may use this forbidden value as a discriminant – + // Option> has the same size as *mut T" + // * The last point remains true for `OwnedSqliteValue` as `#[repr(transparent)] + // guarantees the same layout as the inner type + // * It's unsafe to drop the vector (and the vector elements) + // because of this we wrap the vector (or better the Row) + // Into `ManualDrop` to prevent the dropping + args as *mut [*mut ffi::sqlite3_value] as *mut ffi::sqlite3_value + as *mut Option, + lengths, + lengths, + ) + }; + + Self { + field_count: lengths, + args: Rc::new(RefCell::new(ManuallyDrop::new( + PrivateSqliteRow::Duplicated { + values: args, + column_names: Rc::from(vec![None; lengths]), + }, + ))), + marker: PhantomData, + } + } +} + +impl RowSealed for FunctionRow<'_> {} + +impl<'a> Row<'a, Sqlite> for FunctionRow<'a> { + type Field<'f> = FunctionArgument<'f> where 'a: 'f, Self: 'f; + type InnerPartialRow = Self; + + fn field_count(&self) -> usize { + self.field_count + } + + fn get<'b, I>(&'b self, idx: I) -> Option> + where + 'a: 'b, + Self: crate::row::RowIndex, + { + let idx = self.idx(idx)?; + Some(FunctionArgument { + args: self.args.borrow(), + col_idx: idx as i32, + }) + } + + fn partial_row(&self, range: std::ops::Range) -> PartialRow<'_, Self::InnerPartialRow> { + PartialRow::new(self, range) + } +} + +impl<'a> RowIndex for FunctionRow<'a> { + fn idx(&self, idx: usize) -> Option { + if idx < self.field_count() { + Some(idx) + } else { + None + } + } +} + +impl<'a, 'b> RowIndex<&'a str> for FunctionRow<'b> { + fn idx(&self, _idx: &'a str) -> Option { + None + } +} + +struct FunctionArgument<'a> { + args: Ref<'a, ManuallyDrop>>, + col_idx: i32, +} + +impl<'a> Field<'a, Sqlite> for FunctionArgument<'a> { + fn field_name(&self) -> Option<&str> { + None + } + + fn is_null(&self) -> bool { + self.value().is_none() + } + + fn value(&self) -> Option<::RawValue<'_>> { + SqliteValue::new( + Ref::map(Ref::clone(&self.args), |drop| std::ops::Deref::deref(drop)), + self.col_idx, + ) + } +} diff --git a/diesel-wasm-sqlite/src/connection/mod.rs b/diesel-wasm-sqlite/src/connection/mod.rs new file mode 100644 index 000000000..ca52f98b3 --- /dev/null +++ b/diesel-wasm-sqlite/src/connection/mod.rs @@ -0,0 +1,636 @@ +mod bind_collector; +// mod functions; +// mod owned_row; +mod raw; +// mod row; +// mod serialized_database; +// mod sqlite_value; +// mod statement_iterator; +// mod stmt; + +pub(crate) use self::bind_collector::SqliteBindCollector; +pub use self::bind_collector::SqliteBindValue; +// pub use self::serialized_database::SerializedDatabase; +// pub use self::sqlite_value::SqliteValue; + +/* +use self::raw::RawConnection; +use self::statement_iterator::*; +use self::stmt::{Statement, StatementUse}; +use super::SqliteAggregateFunction; +use crate::connection::instrumentation::StrQueryHelper; +use crate::connection::statement_cache::StatementCache; +use crate::connection::*; +use crate::query_builder::*; +use crate::sqlite::WasmSqlite; +use diesel::deserialize::{FromSqlRow, StaticallySizedRow}; +use diesel::expression::QueryMetadata; +use diesel::result::*; +use diesel::serialize::ToSql; +use diesel::sql_types::{HasSqlType, TypeMetadata}; +*/ +use diesel::{ + backend::Backend, + connection::Instrumentation, + query_builder::{AsQuery, QueryFragment, QueryId}, + result::QueryResult, + row::Field, +}; +use diesel_async::{AnsiTransactionManager, AsyncConnection, SimpleAsyncConnection}; +use futures::stream::Stream; +use std::{ + marker::PhantomData, + pin::Pin, + task::{Context, Poll}, +}; + +use crate::{get_sqlite, get_sqlite_unchecked, WasmSqlite, WasmSqliteError}; +use std::future::Ready; + +unsafe impl Send for WasmSqliteConnection {} +#[derive(Debug)] +pub struct WasmSqliteConnection { + raw: raw::RawConnection, +} + +#[async_trait::async_trait(?Send)] +impl SimpleAsyncConnection for WasmSqliteConnection { + async fn batch_execute(&mut self, query: &str) -> diesel::prelude::QueryResult<()> { + get_sqlite_unchecked() + .batch_execute(&self.raw.internal_connection, query) + .map_err(WasmSqliteError::from) + .map_err(Into::into) + } +} + +/// TODO: The placeholder stuff all needs to be re-done + +pub struct OwnedSqliteFieldPlaceholder<'field> { + field: PhantomData<&'field ()>, +} + +impl<'f> Field<'f, WasmSqlite> for OwnedSqliteFieldPlaceholder<'f> { + fn field_name(&self) -> Option<&str> { + Some("placeholder") + } + fn value(&self) -> Option<::RawValue<'_>> { + todo!() + } +} + +pub struct InnerPartialRowPlaceholder; + +pub struct RowReady(Option<()>); + +impl std::future::Future for RowReady { + type Output = (); + + fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + Poll::Ready(self.0.take().expect("`Ready` polled after completion")) + } +} + +impl diesel::row::RowSealed for RowReady {} + +impl<'a, 'b> diesel::row::RowIndex<&'a str> for RowReady { + fn idx(&self, idx: &'a str) -> Option { + todo!() + } +} + +impl diesel::row::RowIndex for RowReady { + fn idx(&self, idx: usize) -> Option { + todo!() + } +} + +impl<'a> diesel::row::Row<'a, WasmSqlite> for RowReady { + type Field<'f> = OwnedSqliteFieldPlaceholder<'f> + where + 'a: 'f, + Self: 'f; + + type InnerPartialRow = Self; + + fn field_count(&self) -> usize { + todo!() + } + + fn get<'b, I>(&'b self, idx: I) -> Option> + where + 'a: 'b, + Self: diesel::row::RowIndex, + { + todo!() + } + + fn partial_row( + &self, + range: std::ops::Range, + ) -> diesel::row::PartialRow<'_, Self::InnerPartialRow> { + todo!() + } +} + +pub struct RowReadyStreamPlaceholder; + +impl Stream for RowReadyStreamPlaceholder { + type Item = QueryResult; + fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + todo!(); + } +} + +impl diesel::connection::ConnectionSealed for WasmSqliteConnection {} + +#[async_trait::async_trait(?Send)] +impl AsyncConnection for WasmSqliteConnection { + type Backend = WasmSqlite; + type TransactionManager = AnsiTransactionManager; + // placeholders + type ExecuteFuture<'conn, 'query> = Ready>; + type LoadFuture<'conn, 'query> = Ready>>; + type Stream<'conn, 'query> = RowReadyStreamPlaceholder; + type Row<'conn, 'query> = RowReady; + + async fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { + Ok(WasmSqliteConnection { + raw: raw::RawConnection::establish(database_url).await.unwrap(), + }) + } + + fn load<'conn, 'query, T>(&'conn mut self, source: T) -> Self::LoadFuture<'conn, 'query> + where + T: AsQuery + 'query, + T::Query: QueryFragment + QueryId + 'query, + { + todo!() + } + + fn execute_returning_count<'conn, 'query, T>( + &'conn mut self, + source: T, + ) -> Self::ExecuteFuture<'conn, 'query> + where + T: QueryFragment + QueryId + 'query, + { + todo!() + } + + fn transaction_state( + &mut self, + ) -> &mut >::TransactionStateData{ + todo!() + } + + fn instrumentation(&mut self) -> &mut dyn Instrumentation { + todo!() + } + + fn set_instrumentation(&mut self, instrumentation: impl Instrumentation) { + todo!() + } +} + +/* +pub struct SqliteConnection { + // statement_cache needs to be before raw_connection + // otherwise we will get errors about open statements before closing the + // connection itself + statement_cache: StatementCache, + raw_connection: RawConnection, + transaction_state: AnsiTransactionManager, + // this exists for the sole purpose of implementing `WithMetadataLookup` trait + // and avoiding static mut which will be deprecated in 2024 edition + metadata_lookup: (), + instrumentation: Option>, +} +*/ + +// This relies on the invariant that RawConnection or Statement are never +// leaked. If a reference to one of those was held on a different thread, this +// would not be thread safe. +/* +#[allow(unsafe_code)] +unsafe impl Send for SqliteConnection {} + +impl SimpleConnection for SqliteConnection { + fn batch_execute(&mut self, query: &str) -> QueryResult<()> { + self.instrumentation + .on_connection_event(InstrumentationEvent::StartQuery { + query: &StrQueryHelper::new(query), + }); + let resp = self.raw_connection.exec(query); + self.instrumentation + .on_connection_event(InstrumentationEvent::FinishQuery { + query: &StrQueryHelper::new(query), + error: resp.as_ref().err(), + }); + resp + } +} +*/ +/* +impl ConnectionSealed for SqliteConnection {} + +impl Connection for SqliteConnection { + type Backend = Sqlite; + type TransactionManager = AnsiTransactionManager; + + /// Establish a connection to the database specified by `database_url`. + /// + /// See [SqliteConnection] for supported `database_url`. + /// + /// If the database does not exist, this method will try to + /// create a new database and then establish a connection to it. + fn establish(database_url: &str) -> ConnectionResult { + let mut instrumentation = crate::connection::instrumentation::get_default_instrumentation(); + instrumentation.on_connection_event(InstrumentationEvent::StartEstablishConnection { + url: database_url, + }); + + let establish_result = Self::establish_inner(database_url); + instrumentation.on_connection_event(InstrumentationEvent::FinishEstablishConnection { + url: database_url, + error: establish_result.as_ref().err(), + }); + let mut conn = establish_result?; + conn.instrumentation = instrumentation; + Ok(conn) + } + + fn execute_returning_count(&mut self, source: &T) -> QueryResult + where + T: QueryFragment + QueryId, + { + let statement_use = self.prepared_query(source)?; + statement_use + .run() + .map(|_| self.raw_connection.rows_affected_by_last_query()) + } + + fn transaction_state(&mut self) -> &mut AnsiTransactionManager + where + Self: Sized, + { + &mut self.transaction_state + } + + fn instrumentation(&mut self) -> &mut dyn Instrumentation { + &mut self.instrumentation + } + + fn set_instrumentation(&mut self, instrumentation: impl Instrumentation) { + self.instrumentation = Some(Box::new(instrumentation)); + } +} + +impl LoadConnection for SqliteConnection { + type Cursor<'conn, 'query> = StatementIterator<'conn, 'query>; + type Row<'conn, 'query> = self::row::SqliteRow<'conn, 'query>; + + fn load<'conn, 'query, T>( + &'conn mut self, + source: T, + ) -> QueryResult> + where + T: Query + QueryFragment + QueryId + 'query, + Self::Backend: QueryMetadata, + { + let statement = self.prepared_query(source)?; + + Ok(StatementIterator::new(statement)) + } +} + +impl WithMetadataLookup for SqliteConnection { + fn metadata_lookup(&mut self) -> &mut ::MetadataLookup { + &mut self.metadata_lookup + } +} + +#[cfg(feature = "r2d2")] +impl crate::r2d2::R2D2Connection for crate::sqlite::SqliteConnection { + fn ping(&mut self) -> QueryResult<()> { + use crate::RunQueryDsl; + + crate::r2d2::CheckConnectionQuery.execute(self).map(|_| ()) + } + + fn is_broken(&mut self) -> bool { + AnsiTransactionManager::is_broken_transaction_manager(self) + } +} + +impl MultiConnectionHelper for SqliteConnection { + fn to_any<'a>( + lookup: &mut ::MetadataLookup, + ) -> &mut (dyn std::any::Any + 'a) { + lookup + } + + fn from_any( + lookup: &mut dyn std::any::Any, + ) -> Option<&mut ::MetadataLookup> { + lookup.downcast_mut() + } +} + +impl SqliteConnection { + /// Run a transaction with `BEGIN IMMEDIATE` + /// + /// This method will return an error if a transaction is already open. + /// + /// # Example + /// + /// ```rust + /// # include!("../../doctest_setup.rs"); + /// # + /// # fn main() { + /// # run_test().unwrap(); + /// # } + /// # + /// # fn run_test() -> QueryResult<()> { + /// # let mut conn = SqliteConnection::establish(":memory:").unwrap(); + /// conn.immediate_transaction(|conn| { + /// // Do stuff in a transaction + /// Ok(()) + /// }) + /// # } + /// ``` + pub fn immediate_transaction(&mut self, f: F) -> Result + where + F: FnOnce(&mut Self) -> Result, + E: From, + { + self.transaction_sql(f, "BEGIN IMMEDIATE") + } + + /// Run a transaction with `BEGIN EXCLUSIVE` + /// + /// This method will return an error if a transaction is already open. + /// + /// # Example + /// + /// ```rust + /// # include!("../../doctest_setup.rs"); + /// # + /// # fn main() { + /// # run_test().unwrap(); + /// # } + /// # + /// # fn run_test() -> QueryResult<()> { + /// # let mut conn = SqliteConnection::establish(":memory:").unwrap(); + /// conn.exclusive_transaction(|conn| { + /// // Do stuff in a transaction + /// Ok(()) + /// }) + /// # } + /// ``` + pub fn exclusive_transaction(&mut self, f: F) -> Result + where + F: FnOnce(&mut Self) -> Result, + E: From, + { + self.transaction_sql(f, "BEGIN EXCLUSIVE") + } + + fn transaction_sql(&mut self, f: F, sql: &str) -> Result + where + F: FnOnce(&mut Self) -> Result, + E: From, + { + AnsiTransactionManager::begin_transaction_sql(&mut *self, sql)?; + match f(&mut *self) { + Ok(value) => { + AnsiTransactionManager::commit_transaction(&mut *self)?; + Ok(value) + } + Err(e) => { + AnsiTransactionManager::rollback_transaction(&mut *self)?; + Err(e) + } + } + } + + fn prepared_query<'conn, 'query, T>( + &'conn mut self, + source: T, + ) -> QueryResult> + where + T: QueryFragment + QueryId + 'query, + { + self.instrumentation + .on_connection_event(InstrumentationEvent::StartQuery { + query: &crate::debug_query(&source), + }); + let raw_connection = &self.raw_connection; + let cache = &mut self.statement_cache; + let statement = match cache.cached_statement( + &source, + &Sqlite, + &[], + |sql, is_cached| Statement::prepare(raw_connection, sql, is_cached), + &mut self.instrumentation, + ) { + Ok(statement) => statement, + Err(e) => { + self.instrumentation + .on_connection_event(InstrumentationEvent::FinishQuery { + query: &crate::debug_query(&source), + error: Some(&e), + }); + + return Err(e); + } + }; + + StatementUse::bind(statement, source, &mut self.instrumentation) + } + + #[doc(hidden)] + pub fn register_sql_function( + &mut self, + fn_name: &str, + deterministic: bool, + mut f: F, + ) -> QueryResult<()> + where + F: FnMut(Args) -> Ret + std::panic::UnwindSafe + Send + 'static, + Args: FromSqlRow + StaticallySizedRow, + Ret: ToSql, + Sqlite: HasSqlType, + { + functions::register( + &self.raw_connection, + fn_name, + deterministic, + move |_, args| f(args), + ) + } + + #[doc(hidden)] + pub fn register_noarg_sql_function( + &self, + fn_name: &str, + deterministic: bool, + f: F, + ) -> QueryResult<()> + where + F: FnMut() -> Ret + std::panic::UnwindSafe + Send + 'static, + Ret: ToSql, + Sqlite: HasSqlType, + { + functions::register_noargs(&self.raw_connection, fn_name, deterministic, f) + } + + #[doc(hidden)] + pub fn register_aggregate_function( + &mut self, + fn_name: &str, + ) -> QueryResult<()> + where + A: SqliteAggregateFunction + 'static + Send + std::panic::UnwindSafe, + Args: FromSqlRow + StaticallySizedRow, + Ret: ToSql, + Sqlite: HasSqlType, + { + functions::register_aggregate::<_, _, _, _, A>(&self.raw_connection, fn_name) + } + + /// Register a collation function. + /// + /// `collation` must always return the same answer given the same inputs. + /// If `collation` panics and unwinds the stack, the process is aborted, since it is used + /// across a C FFI boundary, which cannot be unwound across and there is no way to + /// signal failures via the SQLite interface in this case.. + /// + /// If the name is already registered it will be overwritten. + /// + /// This method will return an error if registering the function fails, either due to an + /// out-of-memory situation or because a collation with that name already exists and is + /// currently being used in parallel by a query. + /// + /// The collation needs to be specified when creating a table: + /// `CREATE TABLE my_table ( str TEXT COLLATE MY_COLLATION )`, + /// where `MY_COLLATION` corresponds to name passed as `collation_name`. + /// + /// # Example + /// + /// ```rust + /// # include!("../../doctest_setup.rs"); + /// # + /// # fn main() { + /// # run_test().unwrap(); + /// # } + /// # + /// # fn run_test() -> QueryResult<()> { + /// # let mut conn = SqliteConnection::establish(":memory:").unwrap(); + /// // sqlite NOCASE only works for ASCII characters, + /// // this collation allows handling UTF-8 (barring locale differences) + /// conn.register_collation("RUSTNOCASE", |rhs, lhs| { + /// rhs.to_lowercase().cmp(&lhs.to_lowercase()) + /// }) + /// # } + /// ``` + pub fn register_collation(&mut self, collation_name: &str, collation: F) -> QueryResult<()> + where + F: Fn(&str, &str) -> std::cmp::Ordering + Send + 'static + std::panic::UnwindSafe, + { + self.raw_connection + .register_collation_function(collation_name, collation) + } + + /// Serialize the current SQLite database into a byte buffer. + /// + /// The serialized data is identical to the data that would be written to disk if the database + /// was saved in a file. + /// + /// # Returns + /// + /// This function returns a byte slice representing the serialized database. + pub fn serialize_database_to_buffer(&mut self) -> SerializedDatabase { + self.raw_connection.serialize() + } + + /// Deserialize an SQLite database from a byte buffer. + /// + /// This function takes a byte slice and attempts to deserialize it into a SQLite database. + /// If successful, the database is loaded into the connection. If the deserialization fails, + /// an error is returned. + /// + /// The database is opened in READONLY mode. + /// + /// # Example + /// + /// ```no_run + /// # use diesel::sqlite::SerializedDatabase; + /// # use diesel::sqlite::SqliteConnection; + /// # use diesel::result::QueryResult; + /// # use diesel::sql_query; + /// # use diesel::Connection; + /// # use diesel::RunQueryDsl; + /// # fn main() { + /// let connection = &mut SqliteConnection::establish(":memory:").unwrap(); + /// + /// sql_query("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)") + /// .execute(connection).unwrap(); + /// sql_query("INSERT INTO users (name, email) VALUES ('John Doe', 'john.doe@example.com'), ('Jane Doe', 'jane.doe@example.com')") + /// .execute(connection).unwrap(); + /// + /// // Serialize the database to a byte vector + /// let serialized_db: SerializedDatabase = connection.serialize_database_to_buffer(); + /// + /// // Create a new in-memory SQLite database + /// let connection = &mut SqliteConnection::establish(":memory:").unwrap(); + /// + /// // Deserialize the byte vector into the new database + /// connection.deserialize_readonly_database_from_buffer(serialized_db.as_slice()).unwrap(); + /// # + /// # } + /// ``` + pub fn deserialize_readonly_database_from_buffer(&mut self, data: &[u8]) -> QueryResult<()> { + self.raw_connection.deserialize(data) + } + + fn register_diesel_sql_functions(&self) -> QueryResult<()> { + use crate::sql_types::{Integer, Text}; + + functions::register::( + &self.raw_connection, + "diesel_manage_updated_at", + false, + |conn, table_name: String| { + conn.exec(&format!( + include_str!("diesel_manage_updated_at.sql"), + table_name = table_name + )) + .expect("Failed to create trigger"); + 0 // have to return *something* + }, + ) + } + + fn establish_inner(database_url: &str) -> Result { + use crate::result::ConnectionError::CouldntSetupConfiguration; + let raw_connection = RawConnection::establish(database_url)?; + let conn = Self { + statement_cache: StatementCache::new(), + raw_connection, + transaction_state: AnsiTransactionManager::default(), + metadata_lookup: (), + instrumentation: None, + }; + conn.register_diesel_sql_functions() + .map_err(CouldntSetupConfiguration)?; + Ok(conn) + } +} +*/ + +/* +fn error_message(err_code: i32) -> &'static str { + let sqlite3 = crate::get_sqlite_unchecked(); + sqlite3.code_to_str(err_code) +} +*/ diff --git a/diesel-wasm-sqlite/src/connection/owned_row.rs b/diesel-wasm-sqlite/src/connection/owned_row.rs new file mode 100644 index 000000000..43e225d0e --- /dev/null +++ b/diesel-wasm-sqlite/src/connection/owned_row.rs @@ -0,0 +1,92 @@ +use std::sync::Arc; + +use super::sqlite_value::{OwnedSqliteValue, SqliteValue}; +use crate::backend::Backend; +use crate::row::{Field, PartialRow, Row, RowIndex, RowSealed}; +use crate::sqlite::Sqlite; + +#[derive(Debug)] +pub struct OwnedSqliteRow { + pub(super) values: Vec>, + column_names: Arc<[Option]>, +} + +impl OwnedSqliteRow { + pub(super) fn new( + values: Vec>, + column_names: Arc<[Option]>, + ) -> Self { + OwnedSqliteRow { + values, + column_names, + } + } +} + +impl RowSealed for OwnedSqliteRow {} + +impl<'a> Row<'a, Sqlite> for OwnedSqliteRow { + type Field<'field> = OwnedSqliteField<'field> where 'a: 'field, Self: 'field; + type InnerPartialRow = Self; + + fn field_count(&self) -> usize { + self.values.len() + } + + fn get<'field, I>(&'field self, idx: I) -> Option> + where + 'a: 'field, + Self: RowIndex, + { + let idx = self.idx(idx)?; + Some(OwnedSqliteField { + row: self, + col_idx: i32::try_from(idx).ok()?, + }) + } + + fn partial_row(&self, range: std::ops::Range) -> PartialRow<'_, Self::InnerPartialRow> { + PartialRow::new(self, range) + } +} + +impl RowIndex for OwnedSqliteRow { + fn idx(&self, idx: usize) -> Option { + if idx < self.field_count() { + Some(idx) + } else { + None + } + } +} + +impl<'idx> RowIndex<&'idx str> for OwnedSqliteRow { + fn idx(&self, field_name: &'idx str) -> Option { + self.column_names + .iter() + .position(|n| n.as_ref().map(|s| s as &str) == Some(field_name)) + } +} + +#[allow(missing_debug_implementations)] +pub struct OwnedSqliteField<'row> { + pub(super) row: &'row OwnedSqliteRow, + pub(super) col_idx: i32, +} + +impl<'row> Field<'row, Sqlite> for OwnedSqliteField<'row> { + fn field_name(&self) -> Option<&str> { + self.row + .column_names + .get(self.col_idx as usize) + .and_then(|o| o.as_ref().map(|s| s.as_ref())) + } + + fn is_null(&self) -> bool { + self.value().is_none() + } + + fn value(&self) -> Option<::RawValue<'row>> { + SqliteValue::from_owned_row(self.row, self.col_idx) + } +} diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs new file mode 100644 index 000000000..c0e20dbc7 --- /dev/null +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -0,0 +1,606 @@ +#![allow(unsafe_code)] // ffi calls + +// use std::ffi::{CString, NulError}; +// use std::io::{stderr, Write}; +// use std::os::raw as libc; +// use std::ptr::NonNull; +// use std::{mem, ptr, slice, str}; + +// use super::functions::{build_sql_function_args, process_sql_function_result}; +// use super::serialized_database::SerializedDatabase; +// use super::stmt::ensure_sqlite_ok; +// use super::{Sqlite, SqliteAggregateFunction}; +// use crate::deserialize::FromSqlRow; +// use crate::result::Error::DatabaseError; +use crate::sqlite_types::SqliteOpenFlags; +use diesel::result::*; +use diesel::serialize::ToSql; +use diesel::sql_types::HasSqlType; +use wasm_bindgen::JsValue; +/* +/// For use in FFI function, which cannot unwind. +/// Print the message, ask to open an issue at Github and [`abort`](std::process::abort). +macro_rules! assert_fail { + ($fmt:expr $(,$args:tt)*) => { + eprint!(concat!( + $fmt, + "If you see this message, please open an issue at https://github.com/diesel-rs/diesel/issues/new.\n", + "Source location: {}:{}\n", + ), $($args,)* file!(), line!()); + std::process::abort() + }; +} +*/ + +#[allow(missing_copy_implementations)] +#[derive(Debug)] +pub(super) struct RawConnection { + pub(super) internal_connection: JsValue, +} + +impl RawConnection { + pub(super) async fn establish(database_url: &str) -> ConnectionResult { + let sqlite3 = crate::get_sqlite().await; + let database_url = if database_url.starts_with("sqlite://") { + database_url.replacen("sqlite://", "file:", 1) + } else { + database_url.to_string() + }; + let flags = SqliteOpenFlags::SQLITE_OPEN_READWRITE + | SqliteOpenFlags::SQLITE_OPEN_CREATE + | SqliteOpenFlags::SQLITE_OPEN_URI; + + Ok(RawConnection { + internal_connection: sqlite3 + .open_v2(&database_url, Some(flags.bits() as i32)) + .await + .unwrap(), + }) + } + + pub(super) async fn exec(&self, query: &str) -> QueryResult<()> { + let sqlite3 = crate::get_sqlite().await; + let result = sqlite3 + .exec(&self.internal_connection, query) + .await + .unwrap(); + + Ok(result) + } + + pub(super) fn rows_affected_by_last_query(&self) -> usize { + let sqlite3 = crate::get_sqlite_unchecked(); + sqlite3.changes(&self.internal_connection) + } + + /* + pub(super) fn register_sql_function( + &self, + fn_name: &str, + num_args: usize, + deterministic: bool, + f: F, + ) -> QueryResult<()> + where + F: FnMut(&Self, &mut [*mut ffi::sqlite3_value]) -> QueryResult + + std::panic::UnwindSafe + + Send + + 'static, + Ret: ToSql, + Sqlite: HasSqlType, + { + let callback_fn = Box::into_raw(Box::new(CustomFunctionUserPtr { + callback: f, + function_name: fn_name.to_owned(), + })); + let fn_name = Self::get_fn_name(fn_name)?; + let flags = Self::get_flags(deterministic); + + let result = unsafe { + ffi::sqlite3_create_function_v2( + self.internal_connection.as_ptr(), + fn_name.as_ptr(), + num_args as _, + flags, + callback_fn as *mut _, + Some(run_custom_function::), + None, + None, + Some(destroy_boxed::>), + ) + }; + + Self::process_sql_function_result(result) + } + + pub(super) fn register_aggregate_function( + &self, + fn_name: &str, + num_args: usize, + ) -> QueryResult<()> + where + A: SqliteAggregateFunction + 'static + Send + std::panic::UnwindSafe, + Args: FromSqlRow, + Ret: ToSql, + Sqlite: HasSqlType, + { + let fn_name = Self::get_fn_name(fn_name)?; + let flags = Self::get_flags(false); + + let result = unsafe { + ffi::sqlite3_create_function_v2( + self.internal_connection.as_ptr(), + fn_name.as_ptr(), + num_args as _, + flags, + ptr::null_mut(), + None, + Some(run_aggregator_step_function::<_, _, _, _, A>), + Some(run_aggregator_final_function::<_, _, _, _, A>), + None, + ) + }; + + Self::process_sql_function_result(result) + } + + pub(super) fn register_collation_function( + &self, + collation_name: &str, + collation: F, + ) -> QueryResult<()> + where + F: Fn(&str, &str) -> std::cmp::Ordering + std::panic::UnwindSafe + Send + 'static, + { + let callback_fn = Box::into_raw(Box::new(CollationUserPtr { + callback: collation, + collation_name: collation_name.to_owned(), + })); + let collation_name = Self::get_fn_name(collation_name)?; + + let result = unsafe { + ffi::sqlite3_create_collation_v2( + self.internal_connection.as_ptr(), + collation_name.as_ptr(), + ffi::SQLITE_UTF8, + callback_fn as *mut _, + Some(run_collation_function::), + Some(destroy_boxed::>), + ) + }; + + let result = Self::process_sql_function_result(result); + if result.is_err() { + destroy_boxed::>(callback_fn as *mut _); + } + result + } + + pub(super) fn serialize(&mut self) -> SerializedDatabase { + unsafe { + let mut size: ffi::sqlite3_int64 = 0; + let data_ptr = ffi::sqlite3_serialize( + self.internal_connection.as_ptr(), + std::ptr::null(), + &mut size as *mut _, + 0, + ); + SerializedDatabase::new(data_ptr, size as usize) + } + } + + pub(super) fn deserialize(&mut self, data: &[u8]) -> QueryResult<()> { + // the cast for `ffi::SQLITE_DESERIALIZE_READONLY` is required for old libsqlite3-sys versions + #[allow(clippy::unnecessary_cast)] + unsafe { + let result = ffi::sqlite3_deserialize( + self.internal_connection.as_ptr(), + std::ptr::null(), + data.as_ptr() as *mut u8, + data.len() as i64, + data.len() as i64, + ffi::SQLITE_DESERIALIZE_READONLY as u32, + ); + + ensure_sqlite_ok(result, self.internal_connection.as_ptr()) + } + } + + fn get_fn_name(fn_name: &str) -> Result { + CString::new(fn_name) + } + + fn get_flags(deterministic: bool) -> i32 { + let mut flags = ffi::SQLITE_UTF8; + if deterministic { + flags |= ffi::SQLITE_DETERMINISTIC; + } + flags + } + + fn process_sql_function_result(result: i32) -> Result<(), Error> { + if result == ffi::SQLITE_OK { + Ok(()) + } else { + let error_message = super::error_message(result); + Err(DatabaseError( + DatabaseErrorKind::Unknown, + Box::new(error_message.to_string()), + )) + } + } + */ +} +/* +impl Drop for RawConnection { + fn drop(&mut self) { + use std::thread::panicking; + + let sqlite3 = crate::get_sqlite_unchecked(); + + let close_result = sqlite3.close(self.internal_connection); + + if close_result != ffi::SQLITE_OK { + let error_message = super::error_message(close_result); + if panicking() { + write!(stderr(), "Error closing SQLite connection: {error_message}") + .expect("Error writing to `stderr`"); + } else { + panic!("Error closing SQLite connection: {}", error_message); + } + } + } +} +*/ + +/* +enum SqliteCallbackError { + Abort(&'static str), + DieselError(crate::result::Error), + Panic(String), +} + +impl SqliteCallbackError { + fn emit(&self, ctx: *mut ffi::sqlite3_context) { + let s; + let msg = match self { + SqliteCallbackError::Abort(msg) => *msg, + SqliteCallbackError::DieselError(e) => { + s = e.to_string(); + &s + } + SqliteCallbackError::Panic(msg) => msg, + }; + unsafe { + context_error_str(ctx, msg); + } + } +} + +impl From for SqliteCallbackError { + fn from(e: crate::result::Error) -> Self { + Self::DieselError(e) + } +} + +struct CustomFunctionUserPtr { + callback: F, + function_name: String, +} + +#[allow(warnings)] +extern "C" fn run_custom_function( + ctx: *mut ffi::sqlite3_context, + num_args: libc::c_int, + value_ptr: *mut *mut ffi::sqlite3_value, +) where + F: FnMut(&RawConnection, &mut [*mut ffi::sqlite3_value]) -> QueryResult + + std::panic::UnwindSafe + + Send + + 'static, + Ret: ToSql, + Sqlite: HasSqlType, +{ + use std::ops::Deref; + static NULL_DATA_ERR: &str = "An unknown error occurred. sqlite3_user_data returned a null pointer. This should never happen."; + static NULL_CONN_ERR: &str = "An unknown error occurred. sqlite3_context_db_handle returned a null pointer. This should never happen."; + + let conn = match unsafe { NonNull::new(ffi::sqlite3_context_db_handle(ctx)) } { + // We use `ManuallyDrop` here because we do not want to run the + // Drop impl of `RawConnection` as this would close the connection + Some(conn) => mem::ManuallyDrop::new(RawConnection { + internal_connection: conn, + }), + None => { + unsafe { context_error_str(ctx, NULL_CONN_ERR) }; + return; + } + }; + + let data_ptr = unsafe { ffi::sqlite3_user_data(ctx) }; + + let mut data_ptr = match NonNull::new(data_ptr as *mut CustomFunctionUserPtr) { + None => unsafe { + context_error_str(ctx, NULL_DATA_ERR); + return; + }, + Some(mut f) => f, + }; + let data_ptr = unsafe { data_ptr.as_mut() }; + + // We need this to move the reference into the catch_unwind part + // this is sound as `F` itself and the stored string is `UnwindSafe` + let callback = std::panic::AssertUnwindSafe(&mut data_ptr.callback); + + let result = std::panic::catch_unwind(move || { + let _ = &callback; + let args = unsafe { slice::from_raw_parts_mut(value_ptr, num_args as _) }; + let res = (callback.0)(&*conn, args)?; + let value = process_sql_function_result(&res)?; + // We've checked already that ctx is not null + unsafe { + value.result_of(&mut *ctx); + } + Ok(()) + }) + .unwrap_or_else(|p| Err(SqliteCallbackError::Panic(data_ptr.function_name.clone()))); + if let Err(e) = result { + e.emit(ctx); + } +} + +// Need a custom option type here, because the std lib one does not have guarantees about the discriminate values +// See: https://github.com/rust-lang/rfcs/blob/master/text/2195-really-tagged-unions.md#opaque-tags +#[repr(u8)] +enum OptionalAggregator { + // Discriminant is 0 + None, + Some(A), +} + +#[allow(warnings)] +extern "C" fn run_aggregator_step_function( + ctx: *mut ffi::sqlite3_context, + num_args: libc::c_int, + value_ptr: *mut *mut ffi::sqlite3_value, +) where + A: SqliteAggregateFunction + 'static + Send + std::panic::UnwindSafe, + Args: FromSqlRow, + Ret: ToSql, + Sqlite: HasSqlType, +{ + let result = std::panic::catch_unwind(move || { + let args = unsafe { slice::from_raw_parts_mut(value_ptr, num_args as _) }; + run_aggregator_step::(ctx, args) + }) + .unwrap_or_else(|e| { + Err(SqliteCallbackError::Panic(format!( + "{}::step() panicked", + std::any::type_name::() + ))) + }); + + match result { + Ok(()) => {} + Err(e) => e.emit(ctx), + } +} + +fn run_aggregator_step( + ctx: *mut ffi::sqlite3_context, + args: &mut [*mut ffi::sqlite3_value], +) -> Result<(), SqliteCallbackError> +where + A: SqliteAggregateFunction, + Args: FromSqlRow, +{ + static NULL_AG_CTX_ERR: &str = "An unknown error occurred. sqlite3_aggregate_context returned a null pointer. This should never happen."; + static NULL_CTX_ERR: &str = + "We've written the aggregator to the aggregate context, but it could not be retrieved."; + + let aggregate_context = unsafe { + // This block of unsafe code makes the following assumptions: + // + // * sqlite3_aggregate_context allocates sizeof::> + // bytes of zeroed memory as documented here: + // https://www.sqlite.org/c3ref/aggregate_context.html + // A null pointer is returned for negative or zero sized types, + // which should be impossible in theory. We check that nevertheless + // + // * OptionalAggregator::None has a discriminant of 0 as specified by + // #[repr(u8)] + RFC 2195 + // + // * If all bytes are zero, the discriminant is also zero, so we can + // assume that we get OptionalAggregator::None in this case. This is + // not UB as we only access the discriminant here, so we do not try + // to read any other zeroed memory. After that we initialize our enum + // by writing a correct value at this location via ptr::write_unaligned + // + // * We use ptr::write_unaligned as we did not found any guarantees that + // the memory will have a correct alignment. + // (Note I(weiznich): would assume that it is aligned correctly, but we + // we cannot guarantee it, so better be safe than sorry) + ffi::sqlite3_aggregate_context(ctx, std::mem::size_of::>() as i32) + }; + let aggregate_context = NonNull::new(aggregate_context as *mut OptionalAggregator); + let aggregator = unsafe { + match aggregate_context.map(|a| &mut *a.as_ptr()) { + Some(&mut OptionalAggregator::Some(ref mut agg)) => agg, + Some(a_ptr @ &mut OptionalAggregator::None) => { + ptr::write_unaligned(a_ptr as *mut _, OptionalAggregator::Some(A::default())); + if let OptionalAggregator::Some(ref mut agg) = a_ptr { + agg + } else { + return Err(SqliteCallbackError::Abort(NULL_CTX_ERR)); + } + } + None => { + return Err(SqliteCallbackError::Abort(NULL_AG_CTX_ERR)); + } + } + }; + let args = build_sql_function_args::(args)?; + + aggregator.step(args); + Ok(()) +} + +extern "C" fn run_aggregator_final_function( + ctx: *mut ffi::sqlite3_context, +) where + A: SqliteAggregateFunction + 'static + Send, + Args: FromSqlRow, + Ret: ToSql, + Sqlite: HasSqlType, +{ + static NO_AGGREGATOR_FOUND: &str = "We've written to the aggregator in the xStep callback. If xStep was never called, then ffi::sqlite_aggregate_context() would have returned a NULL pointer."; + let aggregate_context = unsafe { + // Within the xFinal callback, it is customary to set nBytes to 0 so no pointless memory + // allocations occur, a null pointer is returned in this case + // See: https://www.sqlite.org/c3ref/aggregate_context.html + // + // For the reasoning about the safety of the OptionalAggregator handling + // see the comment in run_aggregator_step_function. + ffi::sqlite3_aggregate_context(ctx, 0) + }; + + let result = std::panic::catch_unwind(|| { + let mut aggregate_context = NonNull::new(aggregate_context as *mut OptionalAggregator); + + let aggregator = if let Some(a) = aggregate_context.as_mut() { + let a = unsafe { a.as_mut() }; + match std::mem::replace(a, OptionalAggregator::None) { + OptionalAggregator::None => { + return Err(SqliteCallbackError::Abort(NO_AGGREGATOR_FOUND)); + } + OptionalAggregator::Some(a) => Some(a), + } + } else { + None + }; + + let res = A::finalize(aggregator); + let value = process_sql_function_result(&res)?; + // We've checked already that ctx is not null + unsafe { + value.result_of(&mut *ctx); + } + Ok(()) + }) + .unwrap_or_else(|_e| { + Err(SqliteCallbackError::Panic(format!( + "{}::finalize() panicked", + std::any::type_name::() + ))) + }); + if let Err(e) = result { + e.emit(ctx); + } +} + +unsafe fn context_error_str(ctx: *mut ffi::sqlite3_context, error: &str) { + ffi::sqlite3_result_error(ctx, error.as_ptr() as *const _, error.len() as _); +} + +struct CollationUserPtr { + callback: F, + collation_name: String, +} + +#[allow(warnings)] +extern "C" fn run_collation_function( + user_ptr: *mut libc::c_void, + lhs_len: libc::c_int, + lhs_ptr: *const libc::c_void, + rhs_len: libc::c_int, + rhs_ptr: *const libc::c_void, +) -> libc::c_int +where + F: Fn(&str, &str) -> std::cmp::Ordering + Send + std::panic::UnwindSafe + 'static, +{ + let user_ptr = user_ptr as *const CollationUserPtr; + let user_ptr = std::panic::AssertUnwindSafe(unsafe { user_ptr.as_ref() }); + + let result = std::panic::catch_unwind(|| { + let user_ptr = user_ptr.ok_or_else(|| { + SqliteCallbackError::Abort( + "Got a null pointer as data pointer. This should never happen", + ) + })?; + for (ptr, len, side) in &[(rhs_ptr, rhs_len, "rhs"), (lhs_ptr, lhs_len, "lhs")] { + if *len < 0 { + assert_fail!( + "An unknown error occurred. {}_len is negative. This should never happen.", + side + ); + } + if ptr.is_null() { + assert_fail!( + "An unknown error occurred. {}_ptr is a null pointer. This should never happen.", + side + ); + } + } + + let (rhs, lhs) = unsafe { + // Depending on the eTextRep-parameter to sqlite3_create_collation_v2() the strings can + // have various encodings. register_collation_function() always selects SQLITE_UTF8, so the + // pointers point to valid UTF-8 strings (assuming correct behavior of libsqlite3). + ( + str::from_utf8(slice::from_raw_parts(rhs_ptr as *const u8, rhs_len as _)), + str::from_utf8(slice::from_raw_parts(lhs_ptr as *const u8, lhs_len as _)), + ) + }; + + let rhs = + rhs.map_err(|_| SqliteCallbackError::Abort("Got an invalid UTF-8 string for rhs"))?; + let lhs = + lhs.map_err(|_| SqliteCallbackError::Abort("Got an invalid UTF-8 string for lhs"))?; + + Ok((user_ptr.callback)(rhs, lhs)) + }) + .unwrap_or_else(|p| { + Err(SqliteCallbackError::Panic( + user_ptr + .map(|u| u.collation_name.clone()) + .unwrap_or_default(), + )) + }); + + match result { + Ok(std::cmp::Ordering::Less) => -1, + Ok(std::cmp::Ordering::Equal) => 0, + Ok(std::cmp::Ordering::Greater) => 1, + Err(SqliteCallbackError::Abort(a)) => { + eprintln!( + "Collation function {} failed with: {}", + user_ptr + .map(|c| &c.collation_name as &str) + .unwrap_or_default(), + a + ); + std::process::abort() + } + Err(SqliteCallbackError::DieselError(e)) => { + eprintln!( + "Collation function {} failed with: {}", + user_ptr + .map(|c| &c.collation_name as &str) + .unwrap_or_default(), + e + ); + std::process::abort() + } + Err(SqliteCallbackError::Panic(msg)) => { + eprintln!("Collation function {} panicked", msg); + std::process::abort() + } + } +} + +extern "C" fn destroy_boxed(data: *mut libc::c_void) { + let ptr = data as *mut F; + unsafe { std::mem::drop(Box::from_raw(ptr)) }; +} + +*/ diff --git a/diesel-wasm-sqlite/src/connection/row.rs b/diesel-wasm-sqlite/src/connection/row.rs new file mode 100644 index 000000000..75cc27369 --- /dev/null +++ b/diesel-wasm-sqlite/src/connection/row.rs @@ -0,0 +1,408 @@ +use std::cell::{Ref, RefCell}; +use std::rc::Rc; +use std::sync::Arc; + +use super::owned_row::OwnedSqliteRow; +use super::sqlite_value::{OwnedSqliteValue, SqliteValue}; +use super::stmt::StatementUse; +use crate::backend::Backend; +use crate::row::{Field, IntoOwnedRow, PartialRow, Row, RowIndex, RowSealed}; +use crate::sqlite::Sqlite; + +#[allow(missing_debug_implementations)] +pub struct SqliteRow<'stmt, 'query> { + pub(super) inner: Rc>>, + pub(super) field_count: usize, +} + +pub(super) enum PrivateSqliteRow<'stmt, 'query> { + Direct(StatementUse<'stmt, 'query>), + Duplicated { + values: Vec>, + column_names: Rc<[Option]>, + }, +} + +impl<'stmt> IntoOwnedRow<'stmt, Sqlite> for SqliteRow<'stmt, '_> { + type OwnedRow = OwnedSqliteRow; + + type Cache = Option]>>; + + fn into_owned(self, column_name_cache: &mut Self::Cache) -> Self::OwnedRow { + self.inner.borrow().moveable(column_name_cache) + } +} + +impl<'stmt, 'query> PrivateSqliteRow<'stmt, 'query> { + pub(super) fn duplicate( + &mut self, + column_names: &mut Option]>>, + ) -> PrivateSqliteRow<'stmt, 'query> { + match self { + PrivateSqliteRow::Direct(stmt) => { + let column_names = if let Some(column_names) = column_names { + column_names.clone() + } else { + let c: Rc<[Option]> = Rc::from( + (0..stmt.column_count()) + .map(|idx| stmt.field_name(idx).map(|s| s.to_owned())) + .collect::>(), + ); + *column_names = Some(c.clone()); + c + }; + PrivateSqliteRow::Duplicated { + values: (0..stmt.column_count()) + .map(|idx| stmt.copy_value(idx)) + .collect(), + column_names, + } + } + PrivateSqliteRow::Duplicated { + values, + column_names, + } => PrivateSqliteRow::Duplicated { + values: values + .iter() + .map(|v| v.as_ref().map(|v| v.duplicate())) + .collect(), + column_names: column_names.clone(), + }, + } + } + + pub(super) fn moveable( + &self, + column_name_cache: &mut Option]>>, + ) -> OwnedSqliteRow { + match self { + PrivateSqliteRow::Direct(stmt) => { + if column_name_cache.is_none() { + *column_name_cache = Some( + (0..stmt.column_count()) + .map(|idx| stmt.field_name(idx).map(|s| s.to_owned())) + .collect::>() + .into(), + ); + } + let column_names = Arc::clone( + column_name_cache + .as_ref() + .expect("This is initialized above"), + ); + OwnedSqliteRow::new( + (0..stmt.column_count()) + .map(|idx| stmt.copy_value(idx)) + .collect(), + column_names, + ) + } + PrivateSqliteRow::Duplicated { + values, + column_names, + } => { + if column_name_cache.is_none() { + *column_name_cache = Some( + (*column_names) + .iter() + .map(|s| s.to_owned()) + .collect::>() + .into(), + ); + } + let column_names = Arc::clone( + column_name_cache + .as_ref() + .expect("This is initialized above"), + ); + OwnedSqliteRow::new( + values + .iter() + .map(|v| v.as_ref().map(|v| v.duplicate())) + .collect(), + column_names, + ) + } + } + } +} + +impl<'stmt, 'query> RowSealed for SqliteRow<'stmt, 'query> {} + +impl<'stmt, 'query> Row<'stmt, Sqlite> for SqliteRow<'stmt, 'query> { + type Field<'field> = SqliteField<'field, 'field> where 'stmt: 'field, Self: 'field; + type InnerPartialRow = Self; + + fn field_count(&self) -> usize { + self.field_count + } + + fn get<'field, I>(&'field self, idx: I) -> Option> + where + 'stmt: 'field, + Self: RowIndex, + { + let idx = self.idx(idx)?; + Some(SqliteField { + row: self.inner.borrow(), + col_idx: i32::try_from(idx).ok()?, + }) + } + + fn partial_row(&self, range: std::ops::Range) -> PartialRow<'_, Self::InnerPartialRow> { + PartialRow::new(self, range) + } +} + +impl<'stmt, 'query> RowIndex for SqliteRow<'stmt, 'query> { + fn idx(&self, idx: usize) -> Option { + if idx < self.field_count { + Some(idx) + } else { + None + } + } +} + +impl<'stmt, 'idx, 'query> RowIndex<&'idx str> for SqliteRow<'stmt, 'query> { + fn idx(&self, field_name: &'idx str) -> Option { + match &mut *self.inner.borrow_mut() { + PrivateSqliteRow::Direct(stmt) => stmt.index_for_column_name(field_name), + PrivateSqliteRow::Duplicated { column_names, .. } => column_names + .iter() + .position(|n| n.as_ref().map(|s| s as &str) == Some(field_name)), + } + } +} + +#[allow(missing_debug_implementations)] +pub struct SqliteField<'stmt, 'query> { + pub(super) row: Ref<'stmt, PrivateSqliteRow<'stmt, 'query>>, + pub(super) col_idx: i32, +} + +impl<'stmt, 'query> Field<'stmt, Sqlite> for SqliteField<'stmt, 'query> { + fn field_name(&self) -> Option<&str> { + match &*self.row { + PrivateSqliteRow::Direct(stmt) => stmt.field_name(self.col_idx), + PrivateSqliteRow::Duplicated { column_names, .. } => column_names + .get(self.col_idx as usize) + .and_then(|t| t.as_ref().map(|n| n as &str)), + } + } + + fn is_null(&self) -> bool { + self.value().is_none() + } + + fn value(&self) -> Option<::RawValue<'_>> { + SqliteValue::new(Ref::clone(&self.row), self.col_idx) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn fun_with_row_iters() { + crate::table! { + #[allow(unused_parens)] + users(id) { + id -> Integer, + name -> Text, + } + } + + use crate::connection::LoadConnection; + use crate::deserialize::{FromSql, FromSqlRow}; + use crate::prelude::*; + use crate::row::{Field, Row}; + use crate::sql_types; + + let conn = &mut crate::test_helpers::connection(); + + crate::sql_query("CREATE TABLE users(id INTEGER PRIMARY KEY, name TEXT NOT NULL);") + .execute(conn) + .unwrap(); + + crate::insert_into(users::table) + .values(vec![ + (users::id.eq(1), users::name.eq("Sean")), + (users::id.eq(2), users::name.eq("Tess")), + ]) + .execute(conn) + .unwrap(); + + let query = users::table.select((users::id, users::name)); + + let expected = vec![(1, String::from("Sean")), (2, String::from("Tess"))]; + + let row_iter = conn.load(query).unwrap(); + for (row, expected) in row_iter.zip(&expected) { + let row = row.unwrap(); + + let deserialized = <(i32, String) as FromSqlRow< + (sql_types::Integer, sql_types::Text), + _, + >>::build_from_row(&row) + .unwrap(); + + assert_eq!(&deserialized, expected); + } + + { + let collected_rows = conn.load(query).unwrap().collect::>(); + + for (row, expected) in collected_rows.iter().zip(&expected) { + let deserialized = row + .as_ref() + .map(|row| { + <(i32, String) as FromSqlRow< + (sql_types::Integer, sql_types::Text), + _, + >>::build_from_row(row).unwrap() + }) + .unwrap(); + + assert_eq!(&deserialized, expected); + } + } + + let mut row_iter = conn.load(query).unwrap(); + + let first_row = row_iter.next().unwrap().unwrap(); + let first_fields = (first_row.get(0).unwrap(), first_row.get(1).unwrap()); + let first_values = (first_fields.0.value(), first_fields.1.value()); + + assert!(row_iter.next().unwrap().is_err()); + std::mem::drop(first_values); + assert!(row_iter.next().unwrap().is_err()); + std::mem::drop(first_fields); + + let second_row = row_iter.next().unwrap().unwrap(); + let second_fields = (second_row.get(0).unwrap(), second_row.get(1).unwrap()); + let second_values = (second_fields.0.value(), second_fields.1.value()); + + assert!(row_iter.next().unwrap().is_err()); + std::mem::drop(second_values); + assert!(row_iter.next().unwrap().is_err()); + std::mem::drop(second_fields); + + assert!(row_iter.next().is_none()); + + let first_fields = (first_row.get(0).unwrap(), first_row.get(1).unwrap()); + let second_fields = (second_row.get(0).unwrap(), second_row.get(1).unwrap()); + + let first_values = (first_fields.0.value(), first_fields.1.value()); + let second_values = (second_fields.0.value(), second_fields.1.value()); + + assert_eq!( + >::from_nullable_sql(first_values.0) + .unwrap(), + expected[0].0 + ); + assert_eq!( + >::from_nullable_sql(first_values.1) + .unwrap(), + expected[0].1 + ); + + assert_eq!( + >::from_nullable_sql(second_values.0) + .unwrap(), + expected[1].0 + ); + assert_eq!( + >::from_nullable_sql(second_values.1) + .unwrap(), + expected[1].1 + ); + + let first_fields = (first_row.get(0).unwrap(), first_row.get(1).unwrap()); + let first_values = (first_fields.0.value(), first_fields.1.value()); + + assert_eq!( + >::from_nullable_sql(first_values.0) + .unwrap(), + expected[0].0 + ); + assert_eq!( + >::from_nullable_sql(first_values.1) + .unwrap(), + expected[0].1 + ); + } + + #[cfg(feature = "returning_clauses_for_sqlite_3_35")] + crate::define_sql_function! {fn sleep(a: diesel::sql_types::Integer) -> diesel::sql_types::Integer} + + #[test] + #[cfg(feature = "returning_clauses_for_sqlite_3_35")] + fn parallel_iter_with_error() { + use crate::connection::Connection; + use crate::connection::LoadConnection; + use crate::connection::SimpleConnection; + use crate::expression_methods::ExpressionMethods; + use crate::SqliteConnection; + use std::sync::{Arc, Barrier}; + use std::time::Duration; + + let temp_dir = tempfile::tempdir().unwrap(); + let db_path = format!("{}/test.db", temp_dir.path().display()); + let mut conn1 = SqliteConnection::establish(&db_path).unwrap(); + let mut conn2 = SqliteConnection::establish(&db_path).unwrap(); + + crate::table! { + users { + id -> Integer, + name -> Text, + } + } + + conn1 + .batch_execute("CREATE TABLE users(id INTEGER NOT NULL PRIMARY KEY, name TEXT)") + .unwrap(); + + let barrier = Arc::new(Barrier::new(2)); + let barrier2 = barrier.clone(); + + // we unblock the main thread from the sleep function + sleep_utils::register_impl(&mut conn2, move |a: i32| { + barrier.wait(); + std::thread::sleep(Duration::from_secs(a as u64)); + a + }) + .unwrap(); + + // spawn a background thread that locks the database file + let handle = std::thread::spawn(move || { + use crate::query_dsl::RunQueryDsl; + + conn2 + .immediate_transaction(|conn| diesel::select(sleep(1)).execute(conn)) + .unwrap(); + }); + barrier2.wait(); + + // execute some action that also requires a lock + let mut iter = conn1 + .load( + diesel::insert_into(users::table) + .values((users::id.eq(1), users::name.eq("John"))) + .returning(users::id), + ) + .unwrap(); + + // get the first iterator result, that should return the lock error + let n = iter.next().unwrap(); + assert!(n.is_err()); + + // check that the iterator is now empty + let n = iter.next(); + assert!(n.is_none()); + + // join the background thread + handle.join().unwrap(); + } +} diff --git a/diesel-wasm-sqlite/src/connection/serialized_database.rs b/diesel-wasm-sqlite/src/connection/serialized_database.rs new file mode 100644 index 000000000..28a98a286 --- /dev/null +++ b/diesel-wasm-sqlite/src/connection/serialized_database.rs @@ -0,0 +1,45 @@ +#![allow(unsafe_code)] +extern crate libsqlite3_sys as ffi; + +use std::ops::Deref; + +/// `SerializedDatabase` is a wrapper for a serialized database that is dynamically allocated by calling `sqlite3_serialize`. +/// This RAII wrapper is necessary to deallocate the memory when it goes out of scope with `sqlite3_free`. +#[derive(Debug)] +pub struct SerializedDatabase { + data: *mut u8, + len: usize, +} + +impl SerializedDatabase { + /// Creates a new `SerializedDatabase` with the given data pointer and length. + /// + /// SAFETY: The data pointer needs to be returned by sqlite + /// and the length must match the underlying buffer pointer + pub(crate) unsafe fn new(data: *mut u8, len: usize) -> Self { + Self { data, len } + } + + /// Returns a slice of the serialized database. + pub fn as_slice(&self) -> &[u8] { + // The pointer is never null because we don't pass the NO_COPY flag + unsafe { std::slice::from_raw_parts(self.data, self.len) } + } +} + +impl Deref for SerializedDatabase { + type Target = [u8]; + + fn deref(&self) -> &Self::Target { + self.as_slice() + } +} + +impl Drop for SerializedDatabase { + /// Deallocates the memory of the serialized database when it goes out of scope. + fn drop(&mut self) { + unsafe { + ffi::sqlite3_free(self.data as _); + } + } +} diff --git a/diesel-wasm-sqlite/src/connection/sqlite_value.rs b/diesel-wasm-sqlite/src/connection/sqlite_value.rs new file mode 100644 index 000000000..7210d104b --- /dev/null +++ b/diesel-wasm-sqlite/src/connection/sqlite_value.rs @@ -0,0 +1,172 @@ +#![allow(unsafe_code)] // ffi calls +extern crate libsqlite3_sys as ffi; + +use std::cell::Ref; +use std::ptr::NonNull; +use std::{slice, str}; + +use crate::sqlite::SqliteType; + +use super::owned_row::OwnedSqliteRow; +use super::row::PrivateSqliteRow; + +/// Raw sqlite value as received from the database +/// +/// Use existing `FromSql` implementations to convert this into +/// rust values +#[allow(missing_debug_implementations, missing_copy_implementations)] +pub struct SqliteValue<'row, 'stmt, 'query> { + // This field exists to ensure that nobody + // can modify the underlying row while we are + // holding a reference to some row value here + _row: Option>>, + // we extract the raw value pointer as part of the constructor + // to safe the match statements for each method + // According to benchmarks this leads to a ~20-30% speedup + // + // This is sound as long as nobody calls `stmt.step()` + // while holding this value. We ensure this by including + // a reference to the row above. + value: NonNull, +} + +#[derive(Debug)] +#[repr(transparent)] +pub(super) struct OwnedSqliteValue { + pub(super) value: NonNull, +} + +impl Drop for OwnedSqliteValue { + fn drop(&mut self) { + unsafe { ffi::sqlite3_value_free(self.value.as_ptr()) } + } +} + +// Unsafe Send impl safe since sqlite3_value is built with sqlite3_value_dup +// see https://www.sqlite.org/c3ref/value.html +unsafe impl Send for OwnedSqliteValue {} + +impl<'row, 'stmt, 'query> SqliteValue<'row, 'stmt, 'query> { + pub(super) fn new( + row: Ref<'row, PrivateSqliteRow<'stmt, 'query>>, + col_idx: i32, + ) -> Option> { + let value = match &*row { + PrivateSqliteRow::Direct(stmt) => stmt.column_value(col_idx)?, + PrivateSqliteRow::Duplicated { values, .. } => { + values.get(col_idx as usize).and_then(|v| v.as_ref())?.value + } + }; + + let ret = Self { + _row: Some(row), + value, + }; + if ret.value_type().is_none() { + None + } else { + Some(ret) + } + } + + pub(super) fn from_owned_row( + row: &'row OwnedSqliteRow, + col_idx: i32, + ) -> Option> { + let value = row + .values + .get(col_idx as usize) + .and_then(|v| v.as_ref())? + .value; + let ret = Self { _row: None, value }; + if ret.value_type().is_none() { + None + } else { + Some(ret) + } + } + + pub(crate) fn parse_string<'value, R>(&'value self, f: impl FnOnce(&'value str) -> R) -> R { + let s = unsafe { + let ptr = ffi::sqlite3_value_text(self.value.as_ptr()); + let len = ffi::sqlite3_value_bytes(self.value.as_ptr()); + let bytes = slice::from_raw_parts(ptr, len as usize); + // The string is guaranteed to be utf8 according to + // https://www.sqlite.org/c3ref/value_blob.html + str::from_utf8_unchecked(bytes) + }; + f(s) + } + + pub(crate) fn read_text(&self) -> &str { + self.parse_string(|s| s) + } + + pub(crate) fn read_blob(&self) -> &[u8] { + unsafe { + let ptr = ffi::sqlite3_value_blob(self.value.as_ptr()); + let len = ffi::sqlite3_value_bytes(self.value.as_ptr()); + if len == 0 { + // rusts std-lib has an debug_assert that prevents creating + // slices without elements from a pointer + &[] + } else { + slice::from_raw_parts(ptr as *const u8, len as usize) + } + } + } + + pub(crate) fn read_integer(&self) -> i32 { + unsafe { ffi::sqlite3_value_int(self.value.as_ptr()) } + } + + pub(crate) fn read_long(&self) -> i64 { + unsafe { ffi::sqlite3_value_int64(self.value.as_ptr()) } + } + + pub(crate) fn read_double(&self) -> f64 { + unsafe { ffi::sqlite3_value_double(self.value.as_ptr()) } + } + + /// Get the type of the value as returned by sqlite + pub fn value_type(&self) -> Option { + let tpe = unsafe { ffi::sqlite3_value_type(self.value.as_ptr()) }; + match tpe { + ffi::SQLITE_TEXT => Some(SqliteType::Text), + ffi::SQLITE_INTEGER => Some(SqliteType::Long), + ffi::SQLITE_FLOAT => Some(SqliteType::Double), + ffi::SQLITE_BLOB => Some(SqliteType::Binary), + ffi::SQLITE_NULL => None, + _ => unreachable!( + "Sqlite's documentation state that this case ({}) is not reachable. \ + If you ever see this error message please open an issue at \ + https://github.com/diesel-rs/diesel.", + tpe + ), + } + } +} + +impl OwnedSqliteValue { + pub(super) fn copy_from_ptr(ptr: NonNull) -> Option { + let tpe = unsafe { ffi::sqlite3_value_type(ptr.as_ptr()) }; + if ffi::SQLITE_NULL == tpe { + return None; + } + let value = unsafe { ffi::sqlite3_value_dup(ptr.as_ptr()) }; + Some(Self { + value: NonNull::new(value)?, + }) + } + + pub(super) fn duplicate(&self) -> OwnedSqliteValue { + // self.value is a `NonNull` ptr so this cannot be null + let value = unsafe { ffi::sqlite3_value_dup(self.value.as_ptr()) }; + let value = NonNull::new(value).expect( + "Sqlite documentation states this returns only null if value is null \ + or OOM. If you ever see this panic message please open an issue at \ + https://github.com/diesel-rs/diesel.", + ); + OwnedSqliteValue { value } + } +} diff --git a/diesel-wasm-sqlite/src/connection/statement_iterator.rs b/diesel-wasm-sqlite/src/connection/statement_iterator.rs new file mode 100644 index 000000000..393ec9e47 --- /dev/null +++ b/diesel-wasm-sqlite/src/connection/statement_iterator.rs @@ -0,0 +1,172 @@ +use std::cell::RefCell; +use std::rc::Rc; + +use super::row::{PrivateSqliteRow, SqliteRow}; +use super::stmt::StatementUse; +use crate::result::QueryResult; + +#[allow(missing_debug_implementations)] +pub struct StatementIterator<'stmt, 'query> { + inner: PrivateStatementIterator<'stmt, 'query>, + column_names: Option]>>, + field_count: usize, +} + +impl<'stmt, 'query> StatementIterator<'stmt, 'query> { + #[cold] + #[allow(unsafe_code)] // call to unsafe function + fn handle_duplicated_row_case( + outer_last_row: &mut Rc>>, + column_names: &mut Option]>>, + field_count: usize, + ) -> Option>> { + // We don't own the statement. There is another existing reference, likely because + // a user stored the row in some long time container before calling next another time + // In this case we copy out the current values into a temporary store and advance + // the statement iterator internally afterwards + let last_row = { + let mut last_row = match outer_last_row.try_borrow_mut() { + Ok(o) => o, + Err(_e) => { + return Some(Err(crate::result::Error::DeserializationError( + "Failed to reborrow row. Try to release any `SqliteField` or `SqliteValue` \ + that exists at this point" + .into(), + ))); + } + }; + let last_row = &mut *last_row; + let duplicated = last_row.duplicate(column_names); + std::mem::replace(last_row, duplicated) + }; + if let PrivateSqliteRow::Direct(mut stmt) = last_row { + let res = unsafe { + // This is actually safe here as we've already + // performed one step. For the first step we would have + // used `PrivateStatementIterator::NotStarted` where we don't + // have access to `PrivateSqliteRow` at all + stmt.step(false) + }; + *outer_last_row = Rc::new(RefCell::new(PrivateSqliteRow::Direct(stmt))); + match res { + Err(e) => Some(Err(e)), + Ok(false) => None, + Ok(true) => Some(Ok(SqliteRow { + inner: Rc::clone(outer_last_row), + field_count, + })), + } + } else { + // any other state than `PrivateSqliteRow::Direct` is invalid here + // and should not happen. If this ever happens this is a logic error + // in the code above + unreachable!( + "You've reached an impossible internal state. \ + If you ever see this error message please open \ + an issue at https://github.com/diesel-rs/diesel \ + providing example code how to trigger this error." + ) + } + } +} + +enum PrivateStatementIterator<'stmt, 'query> { + NotStarted(Option>), + Started(Rc>>), +} + +impl<'stmt, 'query> StatementIterator<'stmt, 'query> { + pub fn new(stmt: StatementUse<'stmt, 'query>) -> StatementIterator<'stmt, 'query> { + Self { + inner: PrivateStatementIterator::NotStarted(Some(stmt)), + column_names: None, + field_count: 0, + } + } +} + +impl<'stmt, 'query> Iterator for StatementIterator<'stmt, 'query> { + type Item = QueryResult>; + + #[allow(unsafe_code)] // call to unsafe function + fn next(&mut self) -> Option { + use PrivateStatementIterator::{NotStarted, Started}; + match &mut self.inner { + NotStarted(ref mut stmt @ Some(_)) => { + let mut stmt = stmt + .take() + .expect("It must be there because we checked that above"); + let step = unsafe { + // This is safe as we pass `first_step = true` to reset the cached column names + stmt.step(true) + }; + match step { + Err(e) => Some(Err(e)), + Ok(false) => None, + Ok(true) => { + let field_count = stmt.column_count() as usize; + self.field_count = field_count; + let inner = Rc::new(RefCell::new(PrivateSqliteRow::Direct(stmt))); + self.inner = Started(inner.clone()); + Some(Ok(SqliteRow { inner, field_count })) + } + } + } + Started(ref mut last_row) => { + // There was already at least one iteration step + // We check here if the caller already released the row value or not + // by checking if our Rc owns the data or not + if let Some(last_row_ref) = Rc::get_mut(last_row) { + // We own the statement, there is no other reference here. + // This means we don't need to copy out values from the sqlite provided + // datastructures for now + // We don't need to use the runtime borrowing system of the RefCell here + // as we have a mutable reference, so all of this below is checked at compile time + if let PrivateSqliteRow::Direct(ref mut stmt) = last_row_ref.get_mut() { + let step = unsafe { + // This is actually safe here as we've already + // performed one step. For the first step we would have + // used `PrivateStatementIterator::NotStarted` where we don't + // have access to `PrivateSqliteRow` at all + + stmt.step(false) + }; + match step { + Err(e) => Some(Err(e)), + Ok(false) => None, + Ok(true) => { + let field_count = self.field_count; + Some(Ok(SqliteRow { + inner: Rc::clone(last_row), + field_count, + })) + } + } + } else { + // any other state than `PrivateSqliteRow::Direct` is invalid here + // and should not happen. If this ever happens this is a logic error + // in the code above + unreachable!( + "You've reached an impossible internal state. \ + If you ever see this error message please open \ + an issue at https://github.com/diesel-rs/diesel \ + providing example code how to trigger this error." + ) + } + } else { + Self::handle_duplicated_row_case( + last_row, + &mut self.column_names, + self.field_count, + ) + } + } + NotStarted(_s) => { + // we likely got an error while executing the other + // `NotStarted` branch above. In this case we just want to stop + // iterating here + None + } + } + } +} diff --git a/diesel-wasm-sqlite/src/connection/stmt.rs b/diesel-wasm-sqlite/src/connection/stmt.rs new file mode 100644 index 000000000..92b12465d --- /dev/null +++ b/diesel-wasm-sqlite/src/connection/stmt.rs @@ -0,0 +1,540 @@ +#![allow(unsafe_code)] // fii code +use super::bind_collector::{InternalSqliteBindValue, SqliteBindCollector}; +use super::raw::RawConnection; +use super::sqlite_value::OwnedSqliteValue; +use crate::connection::statement_cache::{MaybeCached, PrepareForCache}; +use crate::connection::Instrumentation; +use crate::query_builder::{QueryFragment, QueryId}; +use crate::result::Error::DatabaseError; +use crate::result::*; +use crate::sqlite::{Sqlite, SqliteType}; +use libsqlite3_sys as ffi; +use std::cell::OnceCell; +use std::ffi::{CStr, CString}; +use std::io::{stderr, Write}; +use std::os::raw as libc; +use std::ptr::{self, NonNull}; + +pub(super) struct Statement { + inner_statement: NonNull, +} + +impl Statement { + pub(super) fn prepare( + raw_connection: &RawConnection, + sql: &str, + is_cached: PrepareForCache, + ) -> QueryResult { + let mut stmt = ptr::null_mut(); + let mut unused_portion = ptr::null(); + // the cast for `ffi::SQLITE_PREPARE_PERSISTENT` is required for old libsqlite3-sys versions + #[allow(clippy::unnecessary_cast)] + let prepare_result = unsafe { + ffi::sqlite3_prepare_v3( + raw_connection.internal_connection.as_ptr(), + CString::new(sql)?.as_ptr(), + sql.len() as libc::c_int, + if matches!(is_cached, PrepareForCache::Yes) { + ffi::SQLITE_PREPARE_PERSISTENT as u32 + } else { + 0 + }, + &mut stmt, + &mut unused_portion, + ) + }; + + ensure_sqlite_ok(prepare_result, raw_connection.internal_connection.as_ptr()).map(|_| { + Statement { + inner_statement: unsafe { NonNull::new_unchecked(stmt) }, + } + }) + } + + // The caller of this function has to ensure that: + // * Any buffer provided as `SqliteBindValue::BorrowedBinary`, `SqliteBindValue::Binary` + // `SqliteBindValue::String` or `SqliteBindValue::BorrowedString` is valid + // till either a new value is bound to the same parameter or the underlying + // prepared statement is dropped. + unsafe fn bind( + &mut self, + tpe: SqliteType, + value: InternalSqliteBindValue<'_>, + bind_index: i32, + ) -> QueryResult>> { + let mut ret_ptr = None; + let result = match (tpe, value) { + (_, InternalSqliteBindValue::Null) => { + ffi::sqlite3_bind_null(self.inner_statement.as_ptr(), bind_index) + } + (SqliteType::Binary, InternalSqliteBindValue::BorrowedBinary(bytes)) => { + ffi::sqlite3_bind_blob( + self.inner_statement.as_ptr(), + bind_index, + bytes.as_ptr() as *const libc::c_void, + bytes.len() as libc::c_int, + ffi::SQLITE_STATIC(), + ) + } + (SqliteType::Binary, InternalSqliteBindValue::Binary(mut bytes)) => { + let len = bytes.len(); + // We need a separate pointer here to pass it to sqlite + // as the returned pointer is a pointer to a dyn sized **slice** + // and not the pointer to the first element of the slice + let ptr = bytes.as_mut_ptr(); + ret_ptr = NonNull::new(Box::into_raw(bytes)); + ffi::sqlite3_bind_blob( + self.inner_statement.as_ptr(), + bind_index, + ptr as *const libc::c_void, + len as libc::c_int, + ffi::SQLITE_STATIC(), + ) + } + (SqliteType::Text, InternalSqliteBindValue::BorrowedString(bytes)) => { + ffi::sqlite3_bind_text( + self.inner_statement.as_ptr(), + bind_index, + bytes.as_ptr() as *const libc::c_char, + bytes.len() as libc::c_int, + ffi::SQLITE_STATIC(), + ) + } + (SqliteType::Text, InternalSqliteBindValue::String(bytes)) => { + let mut bytes = Box::<[u8]>::from(bytes); + let len = bytes.len(); + // We need a separate pointer here to pass it to sqlite + // as the returned pointer is a pointer to a dyn sized **slice** + // and not the pointer to the first element of the slice + let ptr = bytes.as_mut_ptr(); + ret_ptr = NonNull::new(Box::into_raw(bytes)); + ffi::sqlite3_bind_text( + self.inner_statement.as_ptr(), + bind_index, + ptr as *const libc::c_char, + len as libc::c_int, + ffi::SQLITE_STATIC(), + ) + } + (SqliteType::Float, InternalSqliteBindValue::F64(value)) + | (SqliteType::Double, InternalSqliteBindValue::F64(value)) => { + ffi::sqlite3_bind_double( + self.inner_statement.as_ptr(), + bind_index, + value as libc::c_double, + ) + } + (SqliteType::SmallInt, InternalSqliteBindValue::I32(value)) + | (SqliteType::Integer, InternalSqliteBindValue::I32(value)) => { + ffi::sqlite3_bind_int(self.inner_statement.as_ptr(), bind_index, value) + } + (SqliteType::Long, InternalSqliteBindValue::I64(value)) => { + ffi::sqlite3_bind_int64(self.inner_statement.as_ptr(), bind_index, value) + } + (t, b) => { + return Err(Error::SerializationError( + format!("Type mismatch: Expected {t:?}, got {b}").into(), + )) + } + }; + match ensure_sqlite_ok(result, self.raw_connection()) { + Ok(()) => Ok(ret_ptr), + Err(e) => { + if let Some(ptr) = ret_ptr { + // This is a `NonNul` ptr so it cannot be null + // It points to a slice internally as we did not apply + // any cast above. + std::mem::drop(Box::from_raw(ptr.as_ptr())) + } + Err(e) + } + } + } + + fn reset(&mut self) { + unsafe { ffi::sqlite3_reset(self.inner_statement.as_ptr()) }; + } + + fn raw_connection(&self) -> *mut ffi::sqlite3 { + unsafe { ffi::sqlite3_db_handle(self.inner_statement.as_ptr()) } + } +} + +pub(super) fn ensure_sqlite_ok( + code: libc::c_int, + raw_connection: *mut ffi::sqlite3, +) -> QueryResult<()> { + if code == ffi::SQLITE_OK { + Ok(()) + } else { + Err(last_error(raw_connection)) + } +} + +fn last_error(raw_connection: *mut ffi::sqlite3) -> Error { + let error_message = last_error_message(raw_connection); + let error_information = Box::new(error_message); + let error_kind = match last_error_code(raw_connection) { + ffi::SQLITE_CONSTRAINT_UNIQUE | ffi::SQLITE_CONSTRAINT_PRIMARYKEY => { + DatabaseErrorKind::UniqueViolation + } + ffi::SQLITE_CONSTRAINT_FOREIGNKEY => DatabaseErrorKind::ForeignKeyViolation, + ffi::SQLITE_CONSTRAINT_NOTNULL => DatabaseErrorKind::NotNullViolation, + ffi::SQLITE_CONSTRAINT_CHECK => DatabaseErrorKind::CheckViolation, + _ => DatabaseErrorKind::Unknown, + }; + DatabaseError(error_kind, error_information) +} + +fn last_error_message(conn: *mut ffi::sqlite3) -> String { + let c_str = unsafe { CStr::from_ptr(ffi::sqlite3_errmsg(conn)) }; + c_str.to_string_lossy().into_owned() +} + +fn last_error_code(conn: *mut ffi::sqlite3) -> libc::c_int { + unsafe { ffi::sqlite3_extended_errcode(conn) } +} + +impl Drop for Statement { + fn drop(&mut self) { + use std::thread::panicking; + + let raw_connection = self.raw_connection(); + let finalize_result = unsafe { ffi::sqlite3_finalize(self.inner_statement.as_ptr()) }; + if let Err(e) = ensure_sqlite_ok(finalize_result, raw_connection) { + if panicking() { + write!( + stderr(), + "Error finalizing SQLite prepared statement: {e:?}" + ) + .expect("Error writing to `stderr`"); + } else { + panic!("Error finalizing SQLite prepared statement: {:?}", e); + } + } + } +} + +// A warning for future editors: +// Changing this code to something "simpler" may +// introduce undefined behaviour. Make sure you read +// the following discussions for details about +// the current version: +// +// * https://github.com/weiznich/diesel/pull/7 +// * https://users.rust-lang.org/t/code-review-for-unsafe-code-in-diesel/66798/ +// * https://github.com/rust-lang/unsafe-code-guidelines/issues/194 +struct BoundStatement<'stmt, 'query> { + statement: MaybeCached<'stmt, Statement>, + // we need to store the query here to ensure no one does + // drop it till the end of the statement + // We use a boxed queryfragment here just to erase the + // generic type, we use NonNull to communicate + // that this is a shared buffer + query: Option + 'query>>, + // we need to store any owned bind values separately, as they are not + // contained in the query itself. We use NonNull to + // communicate that this is a shared buffer + binds_to_free: Vec<(i32, Option>)>, + instrumentation: &'stmt mut dyn Instrumentation, + has_error: bool, +} + +impl<'stmt, 'query> BoundStatement<'stmt, 'query> { + fn bind( + statement: MaybeCached<'stmt, Statement>, + query: T, + instrumentation: &'stmt mut dyn Instrumentation, + ) -> QueryResult> + where + T: QueryFragment + QueryId + 'query, + { + // Don't use a trait object here to prevent using a virtual function call + // For sqlite this can introduce a measurable overhead + // Query is boxed here to make sure it won't move in memory anymore, so any bind + // it could output would stay valid. + let query = Box::new(query); + + let mut bind_collector = SqliteBindCollector::new(); + query.collect_binds(&mut bind_collector, &mut (), &Sqlite)?; + let SqliteBindCollector { binds } = bind_collector; + + let mut ret = BoundStatement { + statement, + query: None, + binds_to_free: Vec::new(), + instrumentation, + has_error: false, + }; + + ret.bind_buffers(binds)?; + + let query = query as Box + 'query>; + ret.query = NonNull::new(Box::into_raw(query)); + + Ok(ret) + } + + // This is a separated function so that + // not the whole constructor is generic over the query type T. + // This hopefully prevents binary bloat. + fn bind_buffers( + &mut self, + binds: Vec<(InternalSqliteBindValue<'_>, SqliteType)>, + ) -> QueryResult<()> { + // It is useful to preallocate `binds_to_free` because it + // - Guarantees that pushing inside it cannot panic, which guarantees the `Drop` + // impl of `BoundStatement` will always re-`bind` as needed + // - Avoids reallocations + self.binds_to_free.reserve( + binds + .iter() + .filter(|&(b, _)| { + matches!( + b, + InternalSqliteBindValue::BorrowedBinary(_) + | InternalSqliteBindValue::BorrowedString(_) + | InternalSqliteBindValue::String(_) + | InternalSqliteBindValue::Binary(_) + ) + }) + .count(), + ); + for (bind_idx, (bind, tpe)) in (1..).zip(binds) { + let is_borrowed_bind = matches!( + bind, + InternalSqliteBindValue::BorrowedString(_) + | InternalSqliteBindValue::BorrowedBinary(_) + ); + + // It's safe to call bind here as: + // * The type and value matches + // * We ensure that corresponding buffers lives long enough below + // * The statement is not used yet by `step` or anything else + let res = unsafe { self.statement.bind(tpe, bind, bind_idx) }?; + + // it's important to push these only after + // the call to bind succeeded, otherwise we might attempt to + // call bind to an non-existing bind position in + // the destructor + if let Some(ptr) = res { + // Store the id + pointer for a owned bind + // as we must unbind and free them on drop + self.binds_to_free.push((bind_idx, Some(ptr))); + } else if is_borrowed_bind { + // Store the id's of borrowed binds to unbind them on drop + self.binds_to_free.push((bind_idx, None)); + } + } + Ok(()) + } + + fn finish_query_with_error(mut self, e: &Error) { + self.has_error = true; + if let Some(q) = self.query { + // it's safe to get a reference from this ptr as it's guaranteed to not be null + let q = unsafe { q.as_ref() }; + self.instrumentation.on_connection_event( + crate::connection::InstrumentationEvent::FinishQuery { + query: &crate::debug_query(&q), + error: Some(e), + }, + ); + } + } +} + +impl<'stmt, 'query> Drop for BoundStatement<'stmt, 'query> { + fn drop(&mut self) { + // First reset the statement, otherwise the bind calls + // below will fails + self.statement.reset(); + + for (idx, buffer) in std::mem::take(&mut self.binds_to_free) { + unsafe { + // It's always safe to bind null values, as there is no buffer that needs to outlife something + self.statement + .bind(SqliteType::Text, InternalSqliteBindValue::Null, idx) + .expect( + "Binding a null value should never fail. \ + If you ever see this error message please open \ + an issue at diesels issue tracker containing \ + code how to trigger this message.", + ); + } + + if let Some(buffer) = buffer { + unsafe { + // Constructing the `Box` here is safe as we + // got the pointer from a box + it is guaranteed to be not null. + std::mem::drop(Box::from_raw(buffer.as_ptr())); + } + } + } + + if let Some(query) = self.query { + let query = unsafe { + // Constructing the `Box` here is safe as we + // got the pointer from a box + it is guaranteed to be not null. + Box::from_raw(query.as_ptr()) + }; + if !self.has_error { + self.instrumentation.on_connection_event( + crate::connection::InstrumentationEvent::FinishQuery { + query: &crate::debug_query(&query), + error: None, + }, + ); + } + std::mem::drop(query); + self.query = None; + } + } +} + +#[allow(missing_debug_implementations)] +pub struct StatementUse<'stmt, 'query> { + statement: BoundStatement<'stmt, 'query>, + column_names: OnceCell>, +} + +impl<'stmt, 'query> StatementUse<'stmt, 'query> { + pub(super) fn bind( + statement: MaybeCached<'stmt, Statement>, + query: T, + instrumentation: &'stmt mut dyn Instrumentation, + ) -> QueryResult> + where + T: QueryFragment + QueryId + 'query, + { + Ok(Self { + statement: BoundStatement::bind(statement, query, instrumentation)?, + column_names: OnceCell::new(), + }) + } + + pub(super) fn run(mut self) -> QueryResult<()> { + let r = unsafe { + // This is safe as we pass `first_step = true` + // and we consume the statement so nobody could + // access the columns later on anyway. + self.step(true).map(|_| ()) + }; + if let Err(ref e) = r { + self.statement.finish_query_with_error(e); + } + r + } + + // This function is marked as unsafe incorrectly passing `false` to `first_step` + // for a first call to this function could cause access to freed memory via + // the cached column names. + // + // It's always safe to call this function with `first_step = true` as this removes + // the cached column names + pub(super) unsafe fn step(&mut self, first_step: bool) -> QueryResult { + let res = match ffi::sqlite3_step(self.statement.statement.inner_statement.as_ptr()) { + ffi::SQLITE_DONE => Ok(false), + ffi::SQLITE_ROW => Ok(true), + _ => Err(last_error(self.statement.statement.raw_connection())), + }; + if first_step { + self.column_names = OnceCell::new(); + } + res + } + + // The returned string pointer is valid until either the prepared statement is + // destroyed by sqlite3_finalize() or until the statement is automatically + // reprepared by the first call to sqlite3_step() for a particular run or + // until the next call to sqlite3_column_name() or sqlite3_column_name16() + // on the same column. + // + // https://sqlite.org/c3ref/column_name.html + // + // Note: This function is marked as unsafe, as calling it can invalidate + // other existing column name pointers on the same column. To prevent that, + // it should maximally be called once per column at all. + unsafe fn column_name(&self, idx: i32) -> *const str { + let name = { + let column_name = + ffi::sqlite3_column_name(self.statement.statement.inner_statement.as_ptr(), idx); + assert!( + !column_name.is_null(), + "The Sqlite documentation states that it only returns a \ + null pointer here if we are in a OOM condition." + ); + CStr::from_ptr(column_name) + }; + name.to_str().expect( + "The Sqlite documentation states that this is UTF8. \ + If you see this error message something has gone \ + horribly wrong. Please open an issue at the \ + diesel repository.", + ) as *const str + } + + pub(super) fn column_count(&self) -> i32 { + unsafe { ffi::sqlite3_column_count(self.statement.statement.inner_statement.as_ptr()) } + } + + pub(super) fn index_for_column_name(&mut self, field_name: &str) -> Option { + (0..self.column_count()) + .find(|idx| self.field_name(*idx) == Some(field_name)) + .map(|v| v as usize) + } + + pub(super) fn field_name(&self, idx: i32) -> Option<&str> { + let column_names = self.column_names.get_or_init(|| { + let count = self.column_count(); + (0..count) + .map(|idx| unsafe { + // By initializing the whole vec at once we ensure that + // we really call this only once. + self.column_name(idx) + }) + .collect() + }); + + column_names + .get(idx as usize) + .and_then(|c| unsafe { c.as_ref() }) + } + + pub(super) fn copy_value(&self, idx: i32) -> Option { + OwnedSqliteValue::copy_from_ptr(self.column_value(idx)?) + } + + pub(super) fn column_value(&self, idx: i32) -> Option> { + let ptr = unsafe { + ffi::sqlite3_column_value(self.statement.statement.inner_statement.as_ptr(), idx) + }; + NonNull::new(ptr) + } +} + +#[cfg(test)] +mod tests { + use crate::prelude::*; + use crate::sql_types::Text; + + // this is a regression test for + // https://github.com/diesel-rs/diesel/issues/3558 + #[test] + fn check_out_of_bounds_bind_does_not_panic_on_drop() { + let mut conn = SqliteConnection::establish(":memory:").unwrap(); + + let e = crate::sql_query("SELECT '?'") + .bind::("foo") + .execute(&mut conn); + + assert!(e.is_err()); + let e = e.unwrap_err(); + if let crate::result::Error::DatabaseError(crate::result::DatabaseErrorKind::Unknown, m) = e + { + assert_eq!(m.message(), "column index out of range"); + } else { + panic!("Wrong error returned"); + } + } +} diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index be6edffd0..c6c62da27 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -1,5 +1,6 @@ use wasm_bindgen::{prelude::*, JsValue}; +/* /// Simple Connection #[wasm_bindgen(module = "/src/package.js")] extern "C" { @@ -9,25 +10,63 @@ extern "C" { #[wasm_bindgen(catch)] pub async fn establish(database_url: &str) -> Result; } +*/ + +// WASM is ran in the browser `main thread`. Tokio is only a single-threaded runtime. +// We need SQLite available globally, so this should be ok until we get threads with WASI or +// something. At which point we can (hopefully) use multi-threaded async runtime to block the +// thread and get SQLite. +unsafe impl Send for SQLite {} +unsafe impl Sync for SQLite {} /// Direct Shim for wa-sqlite #[wasm_bindgen(module = "/src/package.js")] extern "C" { - #[wasm_bindgen] - pub fn sqlite3_result_text(context: i32, value: String); + pub type SQLite; + + #[wasm_bindgen(constructor)] + pub fn new(module: JsValue) -> SQLite; + + #[wasm_bindgen(static_method_of = SQLite)] + pub async fn wasm_module() -> JsValue; + + #[wasm_bindgen(method)] + pub fn result_text(this: &SQLite, context: i32, value: String); + + #[wasm_bindgen(method)] + pub fn result_int(this: &SQLite, context: i32, value: i32); - #[wasm_bindgen] - pub fn sqlite3_result_int(context: i32, value: i32); + #[wasm_bindgen(method)] + pub fn result_int64(this: &SQLite, context: i32, value: i64); - #[wasm_bindgen] - pub fn sqlite3_result_int64(context: i32, value: i64); + #[wasm_bindgen(method)] + pub fn result_double(this: &SQLite, context: i32, value: f64); - #[wasm_bindgen] - pub fn sqlite3_result_double(context: i32, value: f64); + #[wasm_bindgen(method)] + pub fn result_blob(this: &SQLite, context: i32, value: Vec); - #[wasm_bindgen] - pub fn sqlite3_result_blob(context: i32, value: Vec); + #[wasm_bindgen(method)] + pub fn result_null(this: &SQLite, context: i32); + + #[wasm_bindgen(method, catch)] + pub async fn open_v2( + this: &SQLite, + database_url: &str, + iflags: Option, + ) -> Result; + + #[wasm_bindgen(method, catch)] + pub async fn exec(this: &SQLite, database: &JsValue, query: &str) -> Result<(), JsValue>; + + #[wasm_bindgen(method)] + pub fn changes(this: &SQLite, database: &JsValue) -> usize; + + #[wasm_bindgen(method, catch)] + pub fn batch_execute(this: &SQLite, database: &JsValue, query: &str) -> Result<(), JsValue>; +} - #[wasm_bindgen] - pub fn sqlite3_result_null(context: i32); +impl std::fmt::Debug for SQLite { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> { + write!(f, "SQLite WASM bridge") + } } diff --git a/diesel-wasm-sqlite/src/lib.rs b/diesel-wasm-sqlite/src/lib.rs index d8add46ae..d97cbb813 100644 --- a/diesel-wasm-sqlite/src/lib.rs +++ b/diesel-wasm-sqlite/src/lib.rs @@ -6,88 +6,41 @@ pub mod query_builder; pub mod sqlite_types; pub mod utils; +#[cfg(not(target_arch = "wasm32"))] +compile_error!("This crate only suports the `wasm32-unknown-unknown` target"); + +use self::ffi::SQLite; use diesel::{ - connection::{AnsiTransactionManager, Instrumentation, SimpleConnection, TransactionManager}, - query_builder::{QueryFragment, QueryId}, + query_builder::{AsQuery, QueryFragment, QueryId}, result::QueryResult, - Connection, }; +use tokio::sync::OnceCell; use wasm_bindgen::{prelude::wasm_bindgen, JsValue}; pub use backend::{SqliteType, WasmSqlite}; -#[derive(Debug)] -pub struct WasmSqliteConnection { - raw_db_pointer: JsValue, -} - -#[derive(Debug)] -pub struct WasmSqliteError(JsValue); - -impl SimpleConnection for WasmSqliteConnection { - fn batch_execute(&mut self, query: &str) -> diesel::prelude::QueryResult<()> { - ffi::batch_execute(&self.raw_db_pointer, query) - .map_err(WasmSqliteError::from) - .map_err(Into::into) - } -} +/// The SQLite Library +/// this global constant references the loaded SQLite WASM. +static SQLITE: OnceCell = OnceCell::const_new(); -impl diesel::connection::ConnectionSealed for WasmSqliteConnection {} +pub type SQLiteWasm = &'static JsValue; -pub async fn rust_establish( - database_url: &str, -) -> diesel::prelude::ConnectionResult { - let raw_conn = ffi::establish(database_url) +pub(crate) async fn get_sqlite() -> &'static SQLite { + SQLITE + .get_or_init(|| async { + let module = SQLite::wasm_module().await; + SQLite::new(module) + }) .await - .map_err(WasmSqliteError::from) - .map_err(Into::::into)?; - web_sys::console::log_1(&format!("raw conn: {:?}", raw_conn).into()); - Ok(WasmSqliteConnection { - raw_db_pointer: raw_conn, - }) } -unsafe impl Send for WasmSqliteConnection {} -impl Connection for WasmSqliteConnection { - type Backend = WasmSqlite; - type TransactionManager = AnsiTransactionManager; - fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { - todo!(); - } - /* - fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { - let raw_conn = ffi::establish(database_url) - .map_err(WasmSqliteError::from) - .map_err(Into::::into)?; - web_sys::console::log_1(&format!("raw conn: {:?}", raw_conn).into()); - Ok(WasmSqliteConnection { - raw_db_pointer: raw_conn, - }) - } - */ - - fn execute_returning_count(&mut self, source: &T) -> QueryResult - where - T: QueryFragment + QueryId, - { - todo!() - } - - fn transaction_state( - &mut self, - ) -> &mut >::TransactionStateData { - todo!() - } - - fn instrumentation(&mut self) -> &mut dyn Instrumentation { - todo!() - } - - fn set_instrumentation(&mut self, instrumentation: impl diesel::connection::Instrumentation) { - todo!() - } +pub(crate) fn get_sqlite_unchecked() -> &'static SQLite { + SQLITE.get().expect("SQLite is not initialized") } +#[derive(Debug)] +pub struct WasmSqliteError(JsValue); + impl From for diesel::result::Error { fn from(value: WasmSqliteError) -> diesel::result::Error { log::error!("NOT IMPLEMENTED, {:?}", value); @@ -108,25 +61,3 @@ impl From for WasmSqliteError { WasmSqliteError(err) } } - -/* -mod tests { - use super::*; - use wasm_bindgen_test::wasm_bindgen_test; - use web_sys::console; - wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser); - /* - #[wasm_bindgen_test] - fn test_establish() { - let rng: u16 = rand::random(); - let url = format!( - "{}/wasmtest-{}.db3", - std::env::temp_dir().to_str().unwrap(), - rng - ); - let mut conn = WasmSqliteConnection::establish(&url).unwrap(); - println!("{:?}", conn); - } - */ -} -*/ diff --git a/diesel-wasm-sqlite/src/package.js b/diesel-wasm-sqlite/src/package.js index 649b64a76..ba3464210 100644 --- a/diesel-wasm-sqlite/src/package.js +++ b/diesel-wasm-sqlite/src/package.js @@ -1,13 +1,171 @@ // Primary result codes. // https://www.sqlite.org/rescode.html const SQLITE_OK = 0; +const SQLITE_ERROR = 1; +const SQLITE_INTERNAL = 2; +const SQLITE_PERM = 3; +const SQLITE_ABORT = 4; +const SQLITE_BUSY = 5; +const SQLITE_LOCKED = 6; +const SQLITE_NOMEM = 7; +const SQLITE_READONLY = 8; +const SQLITE_INTERRUPT = 9; +const SQLITE_IOERR = 10; +const SQLITE_CORRUPT = 11; +const SQLITE_NOTFOUND = 12; +const SQLITE_FULL = 13; +const SQLITE_CANTOPEN = 14; +const SQLITE_PROTOCOL = 15; +const SQLITE_EMPTY = 16; +const SQLITE_SCHEMA = 17; +const SQLITE_TOOBIG = 18; +const SQLITE_CONSTRAINT = 19; +const SQLITE_MISMATCH = 20; const SQLITE_MISUSE = 21; +const SQLITE_NOLFS = 22; +const SQLITE_AUTH = 23; +const SQLITE_FORMAT = 24; const SQLITE_RANGE = 25; +const SQLITE_NOTADB = 26; const SQLITE_NOTICE = 27; +const SQLITE_WARNING = 28; const SQLITE_ROW = 100; const SQLITE_DONE = 101; + +// Extended error codes. +const SQLITE_IOERR_ACCESS = 3338; +const SQLITE_IOERR_CHECKRESERVEDLOCK = 3594; +const SQLITE_IOERR_CLOSE = 4106; +const SQLITE_IOERR_DATA = 8202; +const SQLITE_IOERR_DELETE = 2570; +const SQLITE_IOERR_DELETE_NOENT = 5898; +const SQLITE_IOERR_DIR_FSYNC = 1290; +const SQLITE_IOERR_FSTAT = 1802; +const SQLITE_IOERR_FSYNC = 1034; +const SQLITE_IOERR_GETTEMPPATH = 6410; +const SQLITE_IOERR_LOCK = 3850; +const SQLITE_IOERR_NOMEM = 3082; +const SQLITE_IOERR_READ = 266; +const SQLITE_IOERR_RDLOCK = 2314; +const SQLITE_IOERR_SEEK = 5642; +const SQLITE_IOERR_SHORT_READ = 522; +const SQLITE_IOERR_TRUNCATE = 1546; +const SQLITE_IOERR_UNLOCK = 2058; +const SQLITE_IOERR_VNODE = 6922; +const SQLITE_IOERR_WRITE = 778; +const SQLITE_IOERR_BEGIN_ATOMIC = 7434; +const SQLITE_IOERR_COMMIT_ATOMIC = 7690; +const SQLITE_IOERR_ROLLBACK_ATOMIC = 7946; + +// Other extended result codes. +const SQLITE_CONSTRAINT_CHECK = 275; +const SQLITE_CONSTRAINT_COMMITHOOK = 531; +const SQLITE_CONSTRAINT_FOREIGNKEY = 787; +const SQLITE_CONSTRAINT_FUNCTION = 1043; +const SQLITE_CONSTRAINT_NOTNULL = 1299; +const SQLITE_CONSTRAINT_PINNED = 2835; +const SQLITE_CONSTRAINT_PRIMARYKEY = 1555; +const SQLITE_CONSTRAINT_ROWID = 2579; +const SQLITE_CONSTRAINT_TRIGGER = 1811; +const SQLITE_CONSTRAINT_UNIQUE = 2067; +const SQLITE_CONSTRAINT_VTAB = 2323; + +// Open flags. +// https://www.sqlite.org/c3ref/c_open_autoproxy.html +const SQLITE_OPEN_READONLY = 0x00000001; const SQLITE_OPEN_READWRITE = 0x00000002; const SQLITE_OPEN_CREATE = 0x00000004; +const SQLITE_OPEN_DELETEONCLOSE = 0x00000008; +const SQLITE_OPEN_EXCLUSIVE = 0x00000010; +const SQLITE_OPEN_AUTOPROXY = 0x00000020; +const SQLITE_OPEN_URI = 0x00000040; +const SQLITE_OPEN_MEMORY = 0x00000080; +const SQLITE_OPEN_MAIN_DB = 0x00000100; +const SQLITE_OPEN_TEMP_DB = 0x00000200; +const SQLITE_OPEN_TRANSIENT_DB = 0x00000400; +const SQLITE_OPEN_MAIN_JOURNAL = 0x00000800; +const SQLITE_OPEN_TEMP_JOURNAL = 0x00001000; +const SQLITE_OPEN_SUBJOURNAL = 0x00002000; +const SQLITE_OPEN_SUPER_JOURNAL = 0x00004000; +const SQLITE_OPEN_NOMUTEX = 0x00008000; +const SQLITE_OPEN_FULLMUTEX = 0x00010000; +const SQLITE_OPEN_SHAREDCACHE = 0x00020000; +const SQLITE_OPEN_PRIVATECACHE = 0x00040000; +const SQLITE_OPEN_WAL = 0x00080000; +const SQLITE_OPEN_NOFOLLOW = 0x01000000; + +// Locking levels. +// https://www.sqlite.org/c3ref/c_lock_exclusive.html +const SQLITE_LOCK_NONE = 0; +const SQLITE_LOCK_SHARED = 1; +const SQLITE_LOCK_RESERVED = 2; +const SQLITE_LOCK_PENDING = 3; +const SQLITE_LOCK_EXCLUSIVE = 4; + +// Device characteristics. +// https://www.sqlite.org/c3ref/c_iocap_atomic.html +const SQLITE_IOCAP_ATOMIC = 0x00000001; +const SQLITE_IOCAP_ATOMIC512 = 0x00000002; +const SQLITE_IOCAP_ATOMIC1K = 0x00000004; +const SQLITE_IOCAP_ATOMIC2K = 0x00000008; +const SQLITE_IOCAP_ATOMIC4K = 0x00000010; +const SQLITE_IOCAP_ATOMIC8K = 0x00000020; +const SQLITE_IOCAP_ATOMIC16K = 0x00000040; +const SQLITE_IOCAP_ATOMIC32K = 0x00000080; +const SQLITE_IOCAP_ATOMIC64K = 0x00000100; +const SQLITE_IOCAP_SAFE_APPEND = 0x00000200; +const SQLITE_IOCAP_SEQUENTIAL = 0x00000400; +const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN = 0x00000800; +const SQLITE_IOCAP_POWERSAFE_OVERWRITE = 0x00001000; +const SQLITE_IOCAP_IMMUTABLE = 0x00002000; +const SQLITE_IOCAP_BATCH_ATOMIC = 0x00004000; + +// xAccess flags. +// https://www.sqlite.org/c3ref/c_access_exists.html +const SQLITE_ACCESS_EXISTS = 0; +const SQLITE_ACCESS_READWRITE = 1; +const SQLITE_ACCESS_READ = 2; + +// File control opcodes +// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlbeginatomicwrite +const SQLITE_FCNTL_LOCKSTATE = 1; +const SQLITE_FCNTL_GET_LOCKPROXYFILE = 2; +const SQLITE_FCNTL_SET_LOCKPROXYFILE = 3; +const SQLITE_FCNTL_LAST_ERRNO = 4; +const SQLITE_FCNTL_SIZE_HINT = 5; +const SQLITE_FCNTL_CHUNK_SIZE = 6; +const SQLITE_FCNTL_FILE_POINTER = 7; +const SQLITE_FCNTL_SYNC_OMITTED = 8; +const SQLITE_FCNTL_WIN32_AV_RETRY = 9; +const SQLITE_FCNTL_PERSIST_WAL = 10; +const SQLITE_FCNTL_OVERWRITE = 11; +const SQLITE_FCNTL_VFSNAME = 12; +const SQLITE_FCNTL_POWERSAFE_OVERWRITE = 13; +const SQLITE_FCNTL_PRAGMA = 14; +const SQLITE_FCNTL_BUSYHANDLER = 15; +const SQLITE_FCNTL_TEMPFILENAME = 16; +const SQLITE_FCNTL_MMAP_SIZE = 18; +const SQLITE_FCNTL_TRACE = 19; +const SQLITE_FCNTL_HAS_MOVED = 20; +const SQLITE_FCNTL_SYNC = 21; +const SQLITE_FCNTL_COMMIT_PHASETWO = 22; +const SQLITE_FCNTL_WIN32_SET_HANDLE = 23; +const SQLITE_FCNTL_WAL_BLOCK = 24; +const SQLITE_FCNTL_ZIPVFS = 25; +const SQLITE_FCNTL_RBU = 26; +const SQLITE_FCNTL_VFS_POINTER = 27; +const SQLITE_FCNTL_JOURNAL_POINTER = 28; +const SQLITE_FCNTL_WIN32_GET_HANDLE = 29; +const SQLITE_FCNTL_PDB = 30; +const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE = 31; +const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE = 32; +const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE = 33; +const SQLITE_FCNTL_LOCK_TIMEOUT = 34; +const SQLITE_FCNTL_DATA_VERSION = 35; +const SQLITE_FCNTL_SIZE_LIMIT = 36; +const SQLITE_FCNTL_CKPT_DONE = 37; +const SQLITE_FCNTL_RESERVE_BYTES = 38; +const SQLITE_FCNTL_CKPT_START = 39; // Fundamental datatypes. // https://www.sqlite.org/c3ref/c_blob.html @@ -17,6 +175,105 @@ const SQLITE_TEXT = 3; const SQLITE_BLOB = 4; const SQLITE_NULL = 5; +// Special destructor behavior. +// https://www.sqlite.org/c3ref/c_static.html +const SQLITE_STATIC = 0; +const SQLITE_TRANSIENT = -1; + +// Text encodings. +// https://sqlite.org/c3ref/c_any.html +const SQLITE_UTF8 = 1; /* IMP: R-37514-35566 */ +const SQLITE_UTF16LE = 2; /* IMP: R-03371-37637 */ +const SQLITE_UTF16BE = 3; /* IMP: R-51971-34154 */ +const SQLITE_UTF16 = 4; /* Use native byte order */ + +// Module constraint ops. +const SQLITE_INDEX_CONSTRAINT_EQ = 2; +const SQLITE_INDEX_CONSTRAINT_GT = 4; +const SQLITE_INDEX_CONSTRAINT_LE = 8; +const SQLITE_INDEX_CONSTRAINT_LT = 16; +const SQLITE_INDEX_CONSTRAINT_GE = 32; +const SQLITE_INDEX_CONSTRAINT_MATCH = 64; +const SQLITE_INDEX_CONSTRAINT_LIKE = 65; +const SQLITE_INDEX_CONSTRAINT_GLOB = 66; +const SQLITE_INDEX_CONSTRAINT_REGEXP = 67; +const SQLITE_INDEX_CONSTRAINT_NE = 68; +const SQLITE_INDEX_CONSTRAINT_ISNOT = 69; +const SQLITE_INDEX_CONSTRAINT_ISNOTNULL = 70; +const SQLITE_INDEX_CONSTRAINT_ISNULL = 71; +const SQLITE_INDEX_CONSTRAINT_IS = 72; +const SQLITE_INDEX_CONSTRAINT_FUNCTION = 150; +const SQLITE_INDEX_SCAN_UNIQUE = 1; /* Scan visits at most = 1 row */ + +// Function flags +const SQLITE_DETERMINISTIC = 0x000000800; +const SQLITE_DIRECTONLY = 0x000080000; +const SQLITE_SUBTYPE = 0x000100000; +const SQLITE_INNOCUOUS = 0x000200000; + +// Sync flags +const SQLITE_SYNC_NORMAL = 0x00002; +const SQLITE_SYNC_FULL = 0x00003; +const SQLITE_SYNC_DATAONLY = 0x00010; + +// Authorizer action codes +const SQLITE_CREATE_INDEX = 1; +const SQLITE_CREATE_TABLE = 2; +const SQLITE_CREATE_TEMP_INDEX = 3; +const SQLITE_CREATE_TEMP_TABLE = 4; +const SQLITE_CREATE_TEMP_TRIGGER = 5; +const SQLITE_CREATE_TEMP_VIEW = 6; +const SQLITE_CREATE_TRIGGER = 7; +const SQLITE_CREATE_VIEW = 8; +const SQLITE_DELETE = 9; +const SQLITE_DROP_INDEX = 10; +const SQLITE_DROP_TABLE = 11; +const SQLITE_DROP_TEMP_INDEX = 12; +const SQLITE_DROP_TEMP_TABLE = 13; +const SQLITE_DROP_TEMP_TRIGGER = 14; +const SQLITE_DROP_TEMP_VIEW = 15; +const SQLITE_DROP_TRIGGER = 16; +const SQLITE_DROP_VIEW = 17; +const SQLITE_INSERT = 18; +const SQLITE_PRAGMA = 19; +const SQLITE_READ = 20; +const SQLITE_SELECT = 21; +const SQLITE_TRANSACTION = 22; +const SQLITE_UPDATE = 23; +const SQLITE_ATTACH = 24; +const SQLITE_DETACH = 25; +const SQLITE_ALTER_TABLE = 26; +const SQLITE_REINDEX = 27; +const SQLITE_ANALYZE = 28; +const SQLITE_CREATE_VTABLE = 29; +const SQLITE_DROP_VTABLE = 30; +const SQLITE_FUNCTION = 31; +const SQLITE_SAVEPOINT = 32; +const SQLITE_COPY = 0; +const SQLITE_RECURSIVE = 33; + +// Authorizer return codes +const SQLITE_DENY = 1; +const SQLITE_IGNORE = 2; + +// Limit categories +const SQLITE_LIMIT_LENGTH = 0; +const SQLITE_LIMIT_SQL_LENGTH = 1; +const SQLITE_LIMIT_COLUMN = 2; +const SQLITE_LIMIT_EXPR_DEPTH = 3; +const SQLITE_LIMIT_COMPOUND_SELECT = 4; +const SQLITE_LIMIT_VDBE_OP = 5; +const SQLITE_LIMIT_FUNCTION_ARG = 6; +const SQLITE_LIMIT_ATTACHED = 7; +const SQLITE_LIMIT_LIKE_PATTERN_LENGTH = 8; +const SQLITE_LIMIT_VARIABLE_NUMBER = 9; +const SQLITE_LIMIT_TRIGGER_DEPTH = 10; +const SQLITE_LIMIT_WORKER_THREADS = 11; + +const SQLITE_PREPARE_PERSISTENT = 0x01; +const SQLITE_PREPARE_NORMALIZED = 0x02; +const SQLITE_PREPARE_NO_VTAB = 0x04; + // Copyright 2021 Roy T. Hashimoto. All Rights Reserved. @@ -883,6 +1140,244 @@ function decl(s) { return result; } +var WasmSQLiteLibrary = /*#__PURE__*/Object.freeze({ + __proto__: null, + Factory: Factory, + SQLITE_ABORT: SQLITE_ABORT, + SQLITE_ACCESS_EXISTS: SQLITE_ACCESS_EXISTS, + SQLITE_ACCESS_READ: SQLITE_ACCESS_READ, + SQLITE_ACCESS_READWRITE: SQLITE_ACCESS_READWRITE, + SQLITE_ALTER_TABLE: SQLITE_ALTER_TABLE, + SQLITE_ANALYZE: SQLITE_ANALYZE, + SQLITE_ATTACH: SQLITE_ATTACH, + SQLITE_AUTH: SQLITE_AUTH, + SQLITE_BLOB: SQLITE_BLOB, + SQLITE_BUSY: SQLITE_BUSY, + SQLITE_CANTOPEN: SQLITE_CANTOPEN, + SQLITE_CONSTRAINT: SQLITE_CONSTRAINT, + SQLITE_CONSTRAINT_CHECK: SQLITE_CONSTRAINT_CHECK, + SQLITE_CONSTRAINT_COMMITHOOK: SQLITE_CONSTRAINT_COMMITHOOK, + SQLITE_CONSTRAINT_FOREIGNKEY: SQLITE_CONSTRAINT_FOREIGNKEY, + SQLITE_CONSTRAINT_FUNCTION: SQLITE_CONSTRAINT_FUNCTION, + SQLITE_CONSTRAINT_NOTNULL: SQLITE_CONSTRAINT_NOTNULL, + SQLITE_CONSTRAINT_PINNED: SQLITE_CONSTRAINT_PINNED, + SQLITE_CONSTRAINT_PRIMARYKEY: SQLITE_CONSTRAINT_PRIMARYKEY, + SQLITE_CONSTRAINT_ROWID: SQLITE_CONSTRAINT_ROWID, + SQLITE_CONSTRAINT_TRIGGER: SQLITE_CONSTRAINT_TRIGGER, + SQLITE_CONSTRAINT_UNIQUE: SQLITE_CONSTRAINT_UNIQUE, + SQLITE_CONSTRAINT_VTAB: SQLITE_CONSTRAINT_VTAB, + SQLITE_COPY: SQLITE_COPY, + SQLITE_CORRUPT: SQLITE_CORRUPT, + SQLITE_CREATE_INDEX: SQLITE_CREATE_INDEX, + SQLITE_CREATE_TABLE: SQLITE_CREATE_TABLE, + SQLITE_CREATE_TEMP_INDEX: SQLITE_CREATE_TEMP_INDEX, + SQLITE_CREATE_TEMP_TABLE: SQLITE_CREATE_TEMP_TABLE, + SQLITE_CREATE_TEMP_TRIGGER: SQLITE_CREATE_TEMP_TRIGGER, + SQLITE_CREATE_TEMP_VIEW: SQLITE_CREATE_TEMP_VIEW, + SQLITE_CREATE_TRIGGER: SQLITE_CREATE_TRIGGER, + SQLITE_CREATE_VIEW: SQLITE_CREATE_VIEW, + SQLITE_CREATE_VTABLE: SQLITE_CREATE_VTABLE, + SQLITE_DELETE: SQLITE_DELETE, + SQLITE_DENY: SQLITE_DENY, + SQLITE_DETACH: SQLITE_DETACH, + SQLITE_DETERMINISTIC: SQLITE_DETERMINISTIC, + SQLITE_DIRECTONLY: SQLITE_DIRECTONLY, + SQLITE_DONE: SQLITE_DONE, + SQLITE_DROP_INDEX: SQLITE_DROP_INDEX, + SQLITE_DROP_TABLE: SQLITE_DROP_TABLE, + SQLITE_DROP_TEMP_INDEX: SQLITE_DROP_TEMP_INDEX, + SQLITE_DROP_TEMP_TABLE: SQLITE_DROP_TEMP_TABLE, + SQLITE_DROP_TEMP_TRIGGER: SQLITE_DROP_TEMP_TRIGGER, + SQLITE_DROP_TEMP_VIEW: SQLITE_DROP_TEMP_VIEW, + SQLITE_DROP_TRIGGER: SQLITE_DROP_TRIGGER, + SQLITE_DROP_VIEW: SQLITE_DROP_VIEW, + SQLITE_DROP_VTABLE: SQLITE_DROP_VTABLE, + SQLITE_EMPTY: SQLITE_EMPTY, + SQLITE_ERROR: SQLITE_ERROR, + SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, + SQLITE_FCNTL_BUSYHANDLER: SQLITE_FCNTL_BUSYHANDLER, + SQLITE_FCNTL_CHUNK_SIZE: SQLITE_FCNTL_CHUNK_SIZE, + SQLITE_FCNTL_CKPT_DONE: SQLITE_FCNTL_CKPT_DONE, + SQLITE_FCNTL_CKPT_START: SQLITE_FCNTL_CKPT_START, + SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: SQLITE_FCNTL_COMMIT_ATOMIC_WRITE, + SQLITE_FCNTL_COMMIT_PHASETWO: SQLITE_FCNTL_COMMIT_PHASETWO, + SQLITE_FCNTL_DATA_VERSION: SQLITE_FCNTL_DATA_VERSION, + SQLITE_FCNTL_FILE_POINTER: SQLITE_FCNTL_FILE_POINTER, + SQLITE_FCNTL_GET_LOCKPROXYFILE: SQLITE_FCNTL_GET_LOCKPROXYFILE, + SQLITE_FCNTL_HAS_MOVED: SQLITE_FCNTL_HAS_MOVED, + SQLITE_FCNTL_JOURNAL_POINTER: SQLITE_FCNTL_JOURNAL_POINTER, + SQLITE_FCNTL_LAST_ERRNO: SQLITE_FCNTL_LAST_ERRNO, + SQLITE_FCNTL_LOCKSTATE: SQLITE_FCNTL_LOCKSTATE, + SQLITE_FCNTL_LOCK_TIMEOUT: SQLITE_FCNTL_LOCK_TIMEOUT, + SQLITE_FCNTL_MMAP_SIZE: SQLITE_FCNTL_MMAP_SIZE, + SQLITE_FCNTL_OVERWRITE: SQLITE_FCNTL_OVERWRITE, + SQLITE_FCNTL_PDB: SQLITE_FCNTL_PDB, + SQLITE_FCNTL_PERSIST_WAL: SQLITE_FCNTL_PERSIST_WAL, + SQLITE_FCNTL_POWERSAFE_OVERWRITE: SQLITE_FCNTL_POWERSAFE_OVERWRITE, + SQLITE_FCNTL_PRAGMA: SQLITE_FCNTL_PRAGMA, + SQLITE_FCNTL_RBU: SQLITE_FCNTL_RBU, + SQLITE_FCNTL_RESERVE_BYTES: SQLITE_FCNTL_RESERVE_BYTES, + SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE, + SQLITE_FCNTL_SET_LOCKPROXYFILE: SQLITE_FCNTL_SET_LOCKPROXYFILE, + SQLITE_FCNTL_SIZE_HINT: SQLITE_FCNTL_SIZE_HINT, + SQLITE_FCNTL_SIZE_LIMIT: SQLITE_FCNTL_SIZE_LIMIT, + SQLITE_FCNTL_SYNC: SQLITE_FCNTL_SYNC, + SQLITE_FCNTL_SYNC_OMITTED: SQLITE_FCNTL_SYNC_OMITTED, + SQLITE_FCNTL_TEMPFILENAME: SQLITE_FCNTL_TEMPFILENAME, + SQLITE_FCNTL_TRACE: SQLITE_FCNTL_TRACE, + SQLITE_FCNTL_VFSNAME: SQLITE_FCNTL_VFSNAME, + SQLITE_FCNTL_VFS_POINTER: SQLITE_FCNTL_VFS_POINTER, + SQLITE_FCNTL_WAL_BLOCK: SQLITE_FCNTL_WAL_BLOCK, + SQLITE_FCNTL_WIN32_AV_RETRY: SQLITE_FCNTL_WIN32_AV_RETRY, + SQLITE_FCNTL_WIN32_GET_HANDLE: SQLITE_FCNTL_WIN32_GET_HANDLE, + SQLITE_FCNTL_WIN32_SET_HANDLE: SQLITE_FCNTL_WIN32_SET_HANDLE, + SQLITE_FCNTL_ZIPVFS: SQLITE_FCNTL_ZIPVFS, + SQLITE_FLOAT: SQLITE_FLOAT, + SQLITE_FORMAT: SQLITE_FORMAT, + SQLITE_FULL: SQLITE_FULL, + SQLITE_FUNCTION: SQLITE_FUNCTION, + SQLITE_IGNORE: SQLITE_IGNORE, + SQLITE_INDEX_CONSTRAINT_EQ: SQLITE_INDEX_CONSTRAINT_EQ, + SQLITE_INDEX_CONSTRAINT_FUNCTION: SQLITE_INDEX_CONSTRAINT_FUNCTION, + SQLITE_INDEX_CONSTRAINT_GE: SQLITE_INDEX_CONSTRAINT_GE, + SQLITE_INDEX_CONSTRAINT_GLOB: SQLITE_INDEX_CONSTRAINT_GLOB, + SQLITE_INDEX_CONSTRAINT_GT: SQLITE_INDEX_CONSTRAINT_GT, + SQLITE_INDEX_CONSTRAINT_IS: SQLITE_INDEX_CONSTRAINT_IS, + SQLITE_INDEX_CONSTRAINT_ISNOT: SQLITE_INDEX_CONSTRAINT_ISNOT, + SQLITE_INDEX_CONSTRAINT_ISNOTNULL: SQLITE_INDEX_CONSTRAINT_ISNOTNULL, + SQLITE_INDEX_CONSTRAINT_ISNULL: SQLITE_INDEX_CONSTRAINT_ISNULL, + SQLITE_INDEX_CONSTRAINT_LE: SQLITE_INDEX_CONSTRAINT_LE, + SQLITE_INDEX_CONSTRAINT_LIKE: SQLITE_INDEX_CONSTRAINT_LIKE, + SQLITE_INDEX_CONSTRAINT_LT: SQLITE_INDEX_CONSTRAINT_LT, + SQLITE_INDEX_CONSTRAINT_MATCH: SQLITE_INDEX_CONSTRAINT_MATCH, + SQLITE_INDEX_CONSTRAINT_NE: SQLITE_INDEX_CONSTRAINT_NE, + SQLITE_INDEX_CONSTRAINT_REGEXP: SQLITE_INDEX_CONSTRAINT_REGEXP, + SQLITE_INDEX_SCAN_UNIQUE: SQLITE_INDEX_SCAN_UNIQUE, + SQLITE_INNOCUOUS: SQLITE_INNOCUOUS, + SQLITE_INSERT: SQLITE_INSERT, + SQLITE_INTEGER: SQLITE_INTEGER, + SQLITE_INTERNAL: SQLITE_INTERNAL, + SQLITE_INTERRUPT: SQLITE_INTERRUPT, + SQLITE_IOCAP_ATOMIC: SQLITE_IOCAP_ATOMIC, + SQLITE_IOCAP_ATOMIC16K: SQLITE_IOCAP_ATOMIC16K, + SQLITE_IOCAP_ATOMIC1K: SQLITE_IOCAP_ATOMIC1K, + SQLITE_IOCAP_ATOMIC2K: SQLITE_IOCAP_ATOMIC2K, + SQLITE_IOCAP_ATOMIC32K: SQLITE_IOCAP_ATOMIC32K, + SQLITE_IOCAP_ATOMIC4K: SQLITE_IOCAP_ATOMIC4K, + SQLITE_IOCAP_ATOMIC512: SQLITE_IOCAP_ATOMIC512, + SQLITE_IOCAP_ATOMIC64K: SQLITE_IOCAP_ATOMIC64K, + SQLITE_IOCAP_ATOMIC8K: SQLITE_IOCAP_ATOMIC8K, + SQLITE_IOCAP_BATCH_ATOMIC: SQLITE_IOCAP_BATCH_ATOMIC, + SQLITE_IOCAP_IMMUTABLE: SQLITE_IOCAP_IMMUTABLE, + SQLITE_IOCAP_POWERSAFE_OVERWRITE: SQLITE_IOCAP_POWERSAFE_OVERWRITE, + SQLITE_IOCAP_SAFE_APPEND: SQLITE_IOCAP_SAFE_APPEND, + SQLITE_IOCAP_SEQUENTIAL: SQLITE_IOCAP_SEQUENTIAL, + SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN, + SQLITE_IOERR: SQLITE_IOERR, + SQLITE_IOERR_ACCESS: SQLITE_IOERR_ACCESS, + SQLITE_IOERR_BEGIN_ATOMIC: SQLITE_IOERR_BEGIN_ATOMIC, + SQLITE_IOERR_CHECKRESERVEDLOCK: SQLITE_IOERR_CHECKRESERVEDLOCK, + SQLITE_IOERR_CLOSE: SQLITE_IOERR_CLOSE, + SQLITE_IOERR_COMMIT_ATOMIC: SQLITE_IOERR_COMMIT_ATOMIC, + SQLITE_IOERR_DATA: SQLITE_IOERR_DATA, + SQLITE_IOERR_DELETE: SQLITE_IOERR_DELETE, + SQLITE_IOERR_DELETE_NOENT: SQLITE_IOERR_DELETE_NOENT, + SQLITE_IOERR_DIR_FSYNC: SQLITE_IOERR_DIR_FSYNC, + SQLITE_IOERR_FSTAT: SQLITE_IOERR_FSTAT, + SQLITE_IOERR_FSYNC: SQLITE_IOERR_FSYNC, + SQLITE_IOERR_GETTEMPPATH: SQLITE_IOERR_GETTEMPPATH, + SQLITE_IOERR_LOCK: SQLITE_IOERR_LOCK, + SQLITE_IOERR_NOMEM: SQLITE_IOERR_NOMEM, + SQLITE_IOERR_RDLOCK: SQLITE_IOERR_RDLOCK, + SQLITE_IOERR_READ: SQLITE_IOERR_READ, + SQLITE_IOERR_ROLLBACK_ATOMIC: SQLITE_IOERR_ROLLBACK_ATOMIC, + SQLITE_IOERR_SEEK: SQLITE_IOERR_SEEK, + SQLITE_IOERR_SHORT_READ: SQLITE_IOERR_SHORT_READ, + SQLITE_IOERR_TRUNCATE: SQLITE_IOERR_TRUNCATE, + SQLITE_IOERR_UNLOCK: SQLITE_IOERR_UNLOCK, + SQLITE_IOERR_VNODE: SQLITE_IOERR_VNODE, + SQLITE_IOERR_WRITE: SQLITE_IOERR_WRITE, + SQLITE_LIMIT_ATTACHED: SQLITE_LIMIT_ATTACHED, + SQLITE_LIMIT_COLUMN: SQLITE_LIMIT_COLUMN, + SQLITE_LIMIT_COMPOUND_SELECT: SQLITE_LIMIT_COMPOUND_SELECT, + SQLITE_LIMIT_EXPR_DEPTH: SQLITE_LIMIT_EXPR_DEPTH, + SQLITE_LIMIT_FUNCTION_ARG: SQLITE_LIMIT_FUNCTION_ARG, + SQLITE_LIMIT_LENGTH: SQLITE_LIMIT_LENGTH, + SQLITE_LIMIT_LIKE_PATTERN_LENGTH: SQLITE_LIMIT_LIKE_PATTERN_LENGTH, + SQLITE_LIMIT_SQL_LENGTH: SQLITE_LIMIT_SQL_LENGTH, + SQLITE_LIMIT_TRIGGER_DEPTH: SQLITE_LIMIT_TRIGGER_DEPTH, + SQLITE_LIMIT_VARIABLE_NUMBER: SQLITE_LIMIT_VARIABLE_NUMBER, + SQLITE_LIMIT_VDBE_OP: SQLITE_LIMIT_VDBE_OP, + SQLITE_LIMIT_WORKER_THREADS: SQLITE_LIMIT_WORKER_THREADS, + SQLITE_LOCKED: SQLITE_LOCKED, + SQLITE_LOCK_EXCLUSIVE: SQLITE_LOCK_EXCLUSIVE, + SQLITE_LOCK_NONE: SQLITE_LOCK_NONE, + SQLITE_LOCK_PENDING: SQLITE_LOCK_PENDING, + SQLITE_LOCK_RESERVED: SQLITE_LOCK_RESERVED, + SQLITE_LOCK_SHARED: SQLITE_LOCK_SHARED, + SQLITE_MISMATCH: SQLITE_MISMATCH, + SQLITE_MISUSE: SQLITE_MISUSE, + SQLITE_NOLFS: SQLITE_NOLFS, + SQLITE_NOMEM: SQLITE_NOMEM, + SQLITE_NOTADB: SQLITE_NOTADB, + SQLITE_NOTFOUND: SQLITE_NOTFOUND, + SQLITE_NOTICE: SQLITE_NOTICE, + SQLITE_NULL: SQLITE_NULL, + SQLITE_OK: SQLITE_OK, + SQLITE_OPEN_AUTOPROXY: SQLITE_OPEN_AUTOPROXY, + SQLITE_OPEN_CREATE: SQLITE_OPEN_CREATE, + SQLITE_OPEN_DELETEONCLOSE: SQLITE_OPEN_DELETEONCLOSE, + SQLITE_OPEN_EXCLUSIVE: SQLITE_OPEN_EXCLUSIVE, + SQLITE_OPEN_FULLMUTEX: SQLITE_OPEN_FULLMUTEX, + SQLITE_OPEN_MAIN_DB: SQLITE_OPEN_MAIN_DB, + SQLITE_OPEN_MAIN_JOURNAL: SQLITE_OPEN_MAIN_JOURNAL, + SQLITE_OPEN_MEMORY: SQLITE_OPEN_MEMORY, + SQLITE_OPEN_NOFOLLOW: SQLITE_OPEN_NOFOLLOW, + SQLITE_OPEN_NOMUTEX: SQLITE_OPEN_NOMUTEX, + SQLITE_OPEN_PRIVATECACHE: SQLITE_OPEN_PRIVATECACHE, + SQLITE_OPEN_READONLY: SQLITE_OPEN_READONLY, + SQLITE_OPEN_READWRITE: SQLITE_OPEN_READWRITE, + SQLITE_OPEN_SHAREDCACHE: SQLITE_OPEN_SHAREDCACHE, + SQLITE_OPEN_SUBJOURNAL: SQLITE_OPEN_SUBJOURNAL, + SQLITE_OPEN_SUPER_JOURNAL: SQLITE_OPEN_SUPER_JOURNAL, + SQLITE_OPEN_TEMP_DB: SQLITE_OPEN_TEMP_DB, + SQLITE_OPEN_TEMP_JOURNAL: SQLITE_OPEN_TEMP_JOURNAL, + SQLITE_OPEN_TRANSIENT_DB: SQLITE_OPEN_TRANSIENT_DB, + SQLITE_OPEN_URI: SQLITE_OPEN_URI, + SQLITE_OPEN_WAL: SQLITE_OPEN_WAL, + SQLITE_PERM: SQLITE_PERM, + SQLITE_PRAGMA: SQLITE_PRAGMA, + SQLITE_PREPARE_NORMALIZED: SQLITE_PREPARE_NORMALIZED, + SQLITE_PREPARE_NO_VTAB: SQLITE_PREPARE_NO_VTAB, + SQLITE_PREPARE_PERSISTENT: SQLITE_PREPARE_PERSISTENT, + SQLITE_PROTOCOL: SQLITE_PROTOCOL, + SQLITE_RANGE: SQLITE_RANGE, + SQLITE_READ: SQLITE_READ, + SQLITE_READONLY: SQLITE_READONLY, + SQLITE_RECURSIVE: SQLITE_RECURSIVE, + SQLITE_REINDEX: SQLITE_REINDEX, + SQLITE_ROW: SQLITE_ROW, + SQLITE_SAVEPOINT: SQLITE_SAVEPOINT, + SQLITE_SCHEMA: SQLITE_SCHEMA, + SQLITE_SELECT: SQLITE_SELECT, + SQLITE_STATIC: SQLITE_STATIC, + SQLITE_SUBTYPE: SQLITE_SUBTYPE, + SQLITE_SYNC_DATAONLY: SQLITE_SYNC_DATAONLY, + SQLITE_SYNC_FULL: SQLITE_SYNC_FULL, + SQLITE_SYNC_NORMAL: SQLITE_SYNC_NORMAL, + SQLITE_TEXT: SQLITE_TEXT, + SQLITE_TOOBIG: SQLITE_TOOBIG, + SQLITE_TRANSACTION: SQLITE_TRANSACTION, + SQLITE_TRANSIENT: SQLITE_TRANSIENT, + SQLITE_UPDATE: SQLITE_UPDATE, + SQLITE_UTF16: SQLITE_UTF16, + SQLITE_UTF16BE: SQLITE_UTF16BE, + SQLITE_UTF16LE: SQLITE_UTF16LE, + SQLITE_UTF8: SQLITE_UTF8, + SQLITE_WARNING: SQLITE_WARNING, + SQLiteError: SQLiteError +}); + var Module = (() => { var _scriptName = import.meta.url; @@ -912,55 +1407,84 @@ function base64Decode(str) { return bytes.buffer; } -const module = await Module({ - "wasmBinary": base64Decode(base64Wasm), -}); +class SQLite { + #module; + #sqlite3; + constructor(module) { + if (typeof module === "undefined") { + throw new Error("Cannot be called directly"); + } -// const module = await initWasmModule(); -const sqlite3 = Factory(module); + this.sqlite3 = Factory(module); + } -function sqlite3_result_text(context, value) { - sqlite3.result_text(context, value); -} + static async wasm_module() { + return await Module({ + "wasmBinary": base64Decode(base64Wasm), + }); + } -function sqlite3_result_int(context, value) { - sqlite3.result_int(context, value); -} + static async build() { + const module = await Module({ + "wasmBinary": base64Decode(base64Wasm), + }); + return new WasmSQLiteLibrary(module); + } -function sqlite3_result_int64(context, value) { - sqlite3.result_int64(context, value); -} + result_text(context, value) { + this.sqlite3.result_text(context, value); + } -function sqlite3_result_double(context, value) { - sqlite3.result_double(context, value); -} + result_int(context, value) { + this.sqlite3.result_int(context, value); + } -function sqlite3_result_blob(context, value) { - sqlite3.result_blob(context, value); -} + result_int64(context, value) { + this.sqlite3.result_int64(context, value); + } -function sqlite3_result_null(context) { - sqlite3.result_null(context); -} + result_double(context, value) { + this.sqlite3.result_double(context, value); + } -async function establish(database_url) { - try { - console.log("Opening database!", database_url); - let db = await sqlite3.open_v2(database_url); - console.log(db); - return db; - } catch { - console.log("establish err"); + result_blob(context, value) { + this.sqlite3.result_blob(context, value); } -} -function batch_execute(database, query) { - try { - sqlite3.exec(database, query); - console.log("Batch exec'ed"); - } catch { - console.log("exec err"); + result_null(context) { + this.sqlite3.result_null(context); + } + + async open_v2(database_url, iflags) { + try { + console.log("Opening database!", database_url); + let db = await this.sqlite3.open_v2(database_url, iflags); + return db; + } catch { + console.log("openv2 error"); + } + } + + async exec(db, query) { + try { + return await this.sqlite3.exec(db, query); + } catch { + console.log('exec err'); + } + } + + changes(db) { + return this.sqlite3.changes(db); + } + + batch_execute(database, query) { + try { + sqlite3.exec(database, query); + console.log("Batch exec'ed"); + } catch { + console.log("exec err"); + } } } -export { batch_execute, establish, sqlite3_result_blob, sqlite3_result_double, sqlite3_result_int, sqlite3_result_int64, sqlite3_result_null, sqlite3_result_text }; +export { SQLite }; diff --git a/diesel-wasm-sqlite/src/query_builder/returning.rs b/diesel-wasm-sqlite/src/query_builder/returning.rs index edc466034..055cab509 100644 --- a/diesel-wasm-sqlite/src/query_builder/returning.rs +++ b/diesel-wasm-sqlite/src/query_builder/returning.rs @@ -2,7 +2,7 @@ use crate::backend::{SqliteReturningClause, WasmSqlite}; use diesel::query_builder::ReturningClause; use diesel::query_builder::{AstPass, QueryFragment}; use diesel::result::QueryResult; - +/* impl QueryFragment for ReturningClause where Expr: QueryFragment, @@ -13,4 +13,4 @@ where self.0.walk_ast(out.reborrow())?; Ok(()) } -} +}*/ diff --git a/diesel-wasm-sqlite/src/sqlite_types.rs b/diesel-wasm-sqlite/src/sqlite_types.rs index 75c2d0d04..a9f1838f7 100644 --- a/diesel-wasm-sqlite/src/sqlite_types.rs +++ b/diesel-wasm-sqlite/src/sqlite_types.rs @@ -1,4 +1,5 @@ use super::backend::{SqliteType, WasmSqlite}; +use bitflags::bitflags; use diesel::sql_types::*; macro_rules! impl_has_sql_type { @@ -23,3 +24,30 @@ impl_has_sql_type!(Binary, SqliteType::Binary); impl_has_sql_type!(Date, SqliteType::Text); impl_has_sql_type!(Time, SqliteType::Text); impl_has_sql_type!(Timestamp, SqliteType::Text); + +bitflags! { + pub struct SqliteOpenFlags: u32 { + const SQLITE_OPEN_READONLY = 0x00000001; /* Ok for sqlite3_open_v2() */ + const SQLITE_OPEN_READWRITE = 0x00000002; /* Ok for sqlite3_open_v2() */ + const SQLITE_OPEN_CREATE = 0x00000004; /* Ok for sqlite3_open_v2() */ + const SQLITE_OPEN_DELETEONCLOSE = 0x00000008; /* VFS only */ + const SQLITE_OPEN_EXCLUSIVE = 0x00000010; /* VFS only */ + const SQLITE_OPEN_AUTOPROXY = 0x00000020; /* VFS only */ + const SQLITE_OPEN_URI = 0x00000040; /* Ok for sqlite3_open_v2() */ + const SQLITE_OPEN_MEMORY = 0x00000080; /* Ok for sqlite3_open_v2() */ + const SQLITE_OPEN_MAIN_DB = 0x00000100; /* VFS only */ + const SQLITE_OPEN_TEMP_DB = 0x00000200; /* VFS only */ + const SQLITE_OPEN_TRANSIENT_DB = 0x00000400; /* VFS only */ + const SQLITE_OPEN_MAIN_JOURNAL = 0x00000800; /* VFS only */ + const SQLITE_OPEN_TEMP_JOURNAL = 0x00001000; /* VFS only */ + const SQLITE_OPEN_SUBJOURNAL = 0x00002000; /* VFS only */ + const SQLITE_OPEN_SUPER_JOURNAL = 0x00004000; /* VFS only */ + const SQLITE_OPEN_NOMUTEX = 0x00008000; /* Ok for sqlite3_open_v2() */ + const SQLITE_OPEN_FULLMUTEX = 0x00010000; /* Ok for sqlite3_open_v2() */ + const SQLITE_OPEN_SHAREDCACHE = 0x00020000; /* Ok for sqlite3_open_v2() */ + const SQLITE_OPEN_PRIVATECACHE = 0x00040000; /* Ok for sqlite3_open_v2() */ + const SQLITE_OPEN_WAL = 0x00080000; /* VFS only */ + const SQLITE_OPEN_NOFOLLOW = 0x01000000; /* Ok for sqlite3_open_v2() */ + const SQLITE_OPEN_EXRESCODE = 0x02000000; /* Extended result codes */ + } +} diff --git a/diesel-wasm-sqlite/tests/web.rs b/diesel-wasm-sqlite/tests/web.rs index 02e52bc53..dd8a6673a 100755 --- a/diesel-wasm-sqlite/tests/web.rs +++ b/diesel-wasm-sqlite/tests/web.rs @@ -4,7 +4,7 @@ use diesel::connection::Connection; use diesel_wasm_sqlite::rust_establish; use wasm_bindgen_test::*; use web_sys::console; -wasm_bindgen_test_configure!(run_in_browser); +wasm_bindgen_test_configure!(run_in_dedicated_worker); #[wasm_bindgen_test] async fn test_establish() { From f374b7e4324140b043cd7bed4e32e7e07ba3e171 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Wed, 24 Jul 2024 21:57:57 -0400 Subject: [PATCH 11/28] wasm-bindgen test runs in web worker! --- diesel-wasm-sqlite/src/connection/mod.rs | 2 +- diesel-wasm-sqlite/src/connection/raw.rs | 1 - diesel-wasm-sqlite/src/wa-sqlite.wasm | Bin 595455 -> 0 bytes diesel-wasm-sqlite/tests/web.rs | 4 ++-- 4 files changed, 3 insertions(+), 4 deletions(-) delete mode 100755 diesel-wasm-sqlite/src/wa-sqlite.wasm diff --git a/diesel-wasm-sqlite/src/connection/mod.rs b/diesel-wasm-sqlite/src/connection/mod.rs index ca52f98b3..86d8bede3 100644 --- a/diesel-wasm-sqlite/src/connection/mod.rs +++ b/diesel-wasm-sqlite/src/connection/mod.rs @@ -36,7 +36,7 @@ use diesel::{ result::QueryResult, row::Field, }; -use diesel_async::{AnsiTransactionManager, AsyncConnection, SimpleAsyncConnection}; +pub use diesel_async::{AnsiTransactionManager, AsyncConnection, SimpleAsyncConnection}; use futures::stream::Stream; use std::{ marker::PhantomData, diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs index c0e20dbc7..fa24ab167 100644 --- a/diesel-wasm-sqlite/src/connection/raw.rs +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -602,5 +602,4 @@ extern "C" fn destroy_boxed(data: *mut libc::c_void) { let ptr = data as *mut F; unsafe { std::mem::drop(Box::from_raw(ptr)) }; } - */ diff --git a/diesel-wasm-sqlite/src/wa-sqlite.wasm b/diesel-wasm-sqlite/src/wa-sqlite.wasm deleted file mode 100755 index 203e3e7cdc1c3b0bb5f3b099e5661c3027a8d587..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 595455 zcmb@v3A`OumH)eISDmq{PAUTslBji#Q7?J}QPY9O^y5~5Fw3BV(*2&^3GpT>35aM1 z5-=j-ghM-`BBG!WMU-{`6%-X`L{!8H6cxn*XH=B;{jFW+-W#Ob|NDF%mzdTHHU`exGF}XY6;Q^W5KLzt469&Yxqy&vg;!r?@V^o9%at>v4W6+&3PbX1~vK z3pqdC?mypJIK$e1fwlZXJFo0_y_Gr8eh;#i54ILI7;J}F`9tmeFnfBqogZPpN80aE zHpVAf$)m0AG4^|`{T}BsAbFD2eX^B*irqineowI9r&`^o+4+g~`*f?dQsw>lxB&GN z;V?O_A^WLtm>w74{-khtW;mQ24$tBcf4Fybui5f(5+{uqAR3Kc)NM9mALordmNcRW z;2-W|m$=xu+$Bq+B=L<#(u%>FYqp!Nu{eq&?_3-wNz+A1dvOwb#|_$x8$ON_p81B) z=_Gn+`(e)cJ@<&+V)|(0&2|(~E8D}lENM1eGuyM_qIMjwjN*2~H9XJ#V;|>|Mk8vq z6BotJIQCK0+>Nq5dP`iAdB59k&1hjW%AzJ<#Cg(cIJbL}#Em4P3WIyRYb5PP0>H6* zMBI!L?-ItA#l98!CZl5nUV})YMze6f?IRyE#CFq139a}BAfUgxE{|NJk;Sg%8p|T* zlSUij#O=t%%cDKwq{)!26&iAlHt_Avqn2A4FLjTMqBWqZ=^HDON5$SZTS>d{-nY<; z-I1)(%4oFvFEKDS+D-7?Xflu}-peIP5k7IV>ZG~;%IP2xtkE4;W?v)f*#;ks-$h!(Y*J^FIZMh2ru=lkZe zq6gQ2&}K7gH@uGv-+<_=~`_@CUSK}N$$d`U>uy} zIk1T_#RW-Yl{k|EKmva(ShQ~wJS|F^4}H|aM%HT3CLL-#P0&EWR@{yEgq}TEhK?e? zxC^O3Saa_^qAV7NHT|B>CGEU;Bp8GqQP%cx<{L$pxD-q_9e>SCG;hK3VsnGI9l@kv z8}@g_ey(Uo?S)Nn(x9G$rVW6GzOa4*D}r}M1_Y7!SsSdiV+iPD7*oV*_?GxFZma-r z+!hTz@~X%_Rpe))KvksVQR`fL|x?KLEY$da$O^S zQL727Q%o!ux4Kaqgf8rM;st1rx&JzIrw=%b7W5&1U*m&we6&EW81xpDE_$e`%@!&h zhNClejuDAka0c|I7*7zAre7GZg0}6L0x12cNkh;EjzOtu@S-%@Uw!C|gZ}FOxYX_0 z>$&?dxJu6z9X{ISSl3)2or_t4qoV~3WC6-R2t*5YTP>JROw$B5K-5SCKiu4kG{DHM z4+GbI7_sfe(UgdyhjXA(((QIJF~X1j6DuHE01e>*2L!bYJt*K)qMh+h2~u>v-@e^9 zbH6RBt~+OC%E6_rtFxDRKQj(XY#eugX!=d#?niC^>~VKz*FR_6-QM-j9e1Bd{VC(_ z=BD2~?tYp0E#vNsJ%8%ByRG9-8+RX1{qx4%wW&XS++CCU=a0LOrT&a@cT417Fz!B@ z`WKG71AWEAre8nqK9c$aIrsjcarX>=@VNV-_Z!CDmm`13xOr<`D4c2Cp-Sware2%A2;q^9r-6Q zgvdX6+@0Z{GVaFx@#F5p9e={OdtK8%b=z~xm-8>DHHB9J->Ov-O%$}CfwDjKXt-=y5~=uaG&b= z=S{fR#QyXNcYV)4-_FmNaM$(x3nttrd;WzJ?h`#<(N52=pKzDO{y?DY`GY3hyS+bn z!hI<98z$UFf5?P;u0M3bT?6(e+&d$G_=Njl>W`RkGycd4_pzQoYQlXKKt9pK7(*1{@oOE|5ernR))bZ1k?gQX%(p?GeCf)mc{^Uvb zzMg;9q}vJZCfya_ZqmIR)|+(Kcm1;`-Q_+1oJn_A+dp^G{jBXznRM>~dz0>~9lwPZ zz}}?$3amHjE(3eC2J20_FL(U&C*7qzf5xPHH`t?nSZ~r@0`?}|JHg(h`)Jc2NRO#M zXwqHW^9N75cl7**Nq14tA2R9Q-t&h}y0?M9N%vN`Z_>R5?wfRPhWjSnn?T^Cdm{*( zbZ_YSqbJ?#d;XY7_e<}O1?JQrH|hSX=btp`Uf1(ao^%)V{8J{~tH9u-doLKAbf53| zr%t;2692SG_ld4Qank)1{+o2K1cj6C6`*j+-PrLHQ|?tQKRM-I-t$va?);vgo^me* zhg0r6a5&{&0uHC#&lCTwDfhXKpP6zm28UB_2mCkXe&6)Zo^me&hg0q|9sk@ZcTUfr zGUd(&hf{7l9606f&;6-W?(exjZOZ*E_s^Sh_vQZdDR%=noN|B7{TWm4FS&ogl>2k; zUpOVnsixegJAOU)Gk@TeySnKQnsR^2{J~T1H7&nk%Kb6(hfKLYWd6`8_ny=rHsvl$ z{ozyYQg{%kGJoWhdw1%OnsUF({1d0#Z!>@NlzV;0A2a2Cllfz(+&!5;Zp!^S^G}*` zzsmfRr`#_y|CA~Bi_9NCll|D0*}+LnLrw7V_yr%b!gXMXdvyD{@yrrl>Vf9kY* z6?{1DK9l+9O}iU1fBLlhbmpHw?LL+HGp613nSa5wyDsxDoOYkgd^PPpk@@x0?pkm- z?Op>8r`gyL(fA;YqOCeuEyIcE3*j_(@pHiId#tyMFQ{_siT*o#Zad{q#xh&!F%m zcX8Ia4HvA6(ktQvf8G66_vP(tk_*yTr!P-mmY$!!G(9hUNqTO2OY)`O9lfu_U+dk} z`)cniy)XCP*ZpDd-q!d1FT20!-rc>W`?Ky{-Jf^A)%|Ao8{Ok??Oq)Jr2FIUkGenX z-qGFggYNgc-|K$2d**k#w{^eW{b~0ny{o%lr_9aWuXS(gezW(D-j91P?S8L!OYarY zi&|gpeyewT?+3l__m2E&^p)Iuv-n+T?n%=8> z=l0&6zcfEDKR17IzCFJy`*!xN?DFir*`?V#vp=T4Pk)#GHoYhPRr<^H7wO&U&(oi! zccni~f0F(G#s_rr$|#OTV4ontm(&X8Miv`uvsoi}HK3pJ%sc zw`O0>K9_ww`%w1U^v&sevNxnJ$^Ml7D7`uTV*2{@ckTa5-<7^Iy*Pbc`VKI4QTq1u zZRuOnucx=9UrIlnekJ{K`qlKa>2>MX(odxqrk_u5NN-AC*Ss6&uGwB!7H>DTH z7sqc*-;rIPp5M7L{Y&@H-Fv%#0zrT5{-OK(?(e$4?f#~FPxqGgtI}7d_ckt$Uy;5z z-I2a1JtsXo-Jagx{d@Os-TS(K?f$O!+um<__w;_<`&I8#-Cy>8(Yw3%qu!mpyLvzC z{k-?9{1^G%`Oov8<#**j&3}^rIKMOhQU1gHj{Nrg2l@B&@8#dkzmwmVe>=Z5|5pCZ z{2Tc#`PcKC^RMMMQvSvK3;E~s8}rZQpUpp$-;jSg|5Scm{>l6k`N#8X z^YinUagRL;m~xclmGg-{kk? zAMgA+|7P}$?3V27+0EH&IyYrs$-bO@Df?pfh3sqDMcLc4w`Fh5F3jGNy*YbR_QvcD z+3U0a%3hbfHhWF>>g0i?KXYb2)W>;jFW$(`3m0gl`e}7qdb+6}2S4O2T1k24t#l)P)1aZl zDNjtsN>_ZYm29gb?u3$MLdgXwmyIf#S?f2c=*e6x*)%h7m0Rlzo+WF2#vxwo+Z_B_ zpOid%LgcxM_ILDKx&2*KHqy5f4s3h4tBQ?-WF_}Uyc@*TS!?}4Wul5%8LQ*sTfQHa z@rXaDI_pT_imPoDNj+z)+`sEa85J9Jal*lQMDwix0qw0cI9FzofS$Xi1{VpH4CHvgQv~l2bm(ojmv|%zCt8Tp> zkew=5J3gh;g^}w=)g|}E`p0z{ZCvYJbt51(1*y�K+^0cIi2H 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%0A`l1&Z@X-qYY@d7cfXeWZ0FL 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

2P%@FFAmc+T<)WrDuWys426lcCwPE+hd}^B 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 YQ%F-u(@5X3 Date: Wed, 24 Jul 2024 22:30:01 -0400 Subject: [PATCH 12/28] opening with OPFS works --- diesel-wasm-sqlite/package.js | 10 +- diesel-wasm-sqlite/src/connection/raw.rs | 5 +- diesel-wasm-sqlite/src/package.js | 1322 +++++++++++++++++++++- diesel-wasm-sqlite/tests/web.rs | 3 +- 4 files changed, 1328 insertions(+), 12 deletions(-) diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index 1d25c662d..fa551d9dc 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -1,4 +1,5 @@ import * as WasmSQLiteLibrary from "@xmtp/wa-sqlite"; +import { OPFSCoopSyncVFS } from "@xmtp/wa-sqlite/vfs/OPFSCoopSync"; import SQLiteESMFactory from "./node_modules/@xmtp/wa-sqlite/dist/wa-sqlite.mjs"; import base64Wasm from "./node_modules/@xmtp/wa-sqlite/dist/wa-sqlite.wasm"; @@ -21,7 +22,7 @@ export class SQLite { if (typeof module === "undefined") { throw new Error("Cannot be called directly"); } - + this.module = module; this.sqlite3 = WasmSQLiteLibrary.Factory(module); } @@ -65,10 +66,13 @@ export class SQLite { async open_v2(database_url, iflags) { try { console.log("Opening database!", database_url); + const vfs = await OPFSCoopSyncVFS.create(database_url, this.module); + this.sqlite3.vfs_register(vfs, true); let db = await this.sqlite3.open_v2(database_url, iflags); return db; - } catch { - console.log("openv2 error"); + } catch (error) { + console.log("openv2 error", error); + throw error; } } diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs index fa24ab167..a8fd17e36 100644 --- a/diesel-wasm-sqlite/src/connection/raw.rs +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -12,7 +12,7 @@ // use super::{Sqlite, SqliteAggregateFunction}; // use crate::deserialize::FromSqlRow; // use crate::result::Error::DatabaseError; -use crate::sqlite_types::SqliteOpenFlags; +use crate::{sqlite_types::SqliteOpenFlags, WasmSqliteError}; use diesel::result::*; use diesel::serialize::ToSql; use diesel::sql_types::HasSqlType; @@ -54,7 +54,8 @@ impl RawConnection { internal_connection: sqlite3 .open_v2(&database_url, Some(flags.bits() as i32)) .await - .unwrap(), + .map_err(WasmSqliteError::from) + .map_err(ConnectionError::from)?, }) } diff --git a/diesel-wasm-sqlite/src/package.js b/diesel-wasm-sqlite/src/package.js index ba3464210..45273a68f 100644 --- a/diesel-wasm-sqlite/src/package.js +++ b/diesel-wasm-sqlite/src/package.js @@ -280,7 +280,7 @@ const SQLITE_PREPARE_NO_VTAB = 0x04; const MAX_INT64 = 0x7fffffffffffffffn; const MIN_INT64 = -0x8000000000000000n; -const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor; +const AsyncFunction$1 = Object.getPrototypeOf(async function(){}).constructor; class SQLiteError extends Error { constructor(message, code) { @@ -652,7 +652,7 @@ function Factory(Module) { // Convert SQLite callback arguments to JavaScript-friendly arguments. function adapt(f) { - return f instanceof AsyncFunction ? + return f instanceof AsyncFunction$1 ? (async (ctx, n, values) => f(ctx, Module.HEAP32.subarray(values / 4, values / 4 + n))) : ((ctx, n, values) => f(ctx, Module.HEAP32.subarray(values / 4, values / 4 + n))); } @@ -891,7 +891,7 @@ function Factory(Module) { Module.UTF8ToString(p6) ]; } function adapt(f) { - return f instanceof AsyncFunction ? + return f instanceof AsyncFunction$1 ? (async (_, iAction, p3, p4, p5, p6) => f(cvtArgs(_, iAction, p3, p4, p5, p6))) : ((_, iAction, p3, p4, p5, p6) => f(cvtArgs(_, iAction, p3, p4, p5, p6))); } @@ -1378,6 +1378,1313 @@ var WasmSQLiteLibrary = /*#__PURE__*/Object.freeze({ SQLiteError: SQLiteError }); +// Copyright 2024 Roy T. Hashimoto. All Rights Reserved. + +const DEFAULT_SECTOR_SIZE = 512; + +// Base class for a VFS. +class Base { + name; + mxPathname = 64; + _module; + + /** + * @param {string} name + * @param {object} module + */ + constructor(name, module) { + this.name = name; + this._module = module; + } + + /** + * @returns {void|Promise} + */ + close() { + } + + /** + * @returns {boolean|Promise} + */ + isReady() { + return true; + } + + /** + * Overload in subclasses to indicate which methods are asynchronous. + * @param {string} methodName + * @returns {boolean} + */ + hasAsyncMethod(methodName) { + return false; + } + + /** + * @param {number} pVfs + * @param {number} zName + * @param {number} pFile + * @param {number} flags + * @param {number} pOutFlags + * @returns {number|Promise} + */ + xOpen(pVfs, zName, pFile, flags, pOutFlags) { + return SQLITE_CANTOPEN; + } + + /** + * @param {number} pVfs + * @param {number} zName + * @param {number} syncDir + * @returns {number|Promise} + */ + xDelete(pVfs, zName, syncDir) { + return SQLITE_OK; + } + + /** + * @param {number} pVfs + * @param {number} zName + * @param {number} flags + * @param {number} pResOut + * @returns {number|Promise} + */ + xAccess(pVfs, zName, flags, pResOut) { + return SQLITE_OK; + } + + /** + * @param {number} pVfs + * @param {number} zName + * @param {number} nOut + * @param {number} zOut + * @returns {number|Promise} + */ + xFullPathname(pVfs, zName, nOut, zOut) { + return SQLITE_OK; + } + + /** + * @param {number} pVfs + * @param {number} nBuf + * @param {number} zBuf + * @returns {number|Promise} + */ + xGetLastError(pVfs, nBuf, zBuf) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @returns {number|Promise} + */ + xClose(pFile) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} pData + * @param {number} iAmt + * @param {number} iOffsetLo + * @param {number} iOffsetHi + * @returns {number|Promise} + */ + xRead(pFile, pData, iAmt, iOffsetLo, iOffsetHi) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} pData + * @param {number} iAmt + * @param {number} iOffsetLo + * @param {number} iOffsetHi + * @returns {number|Promise} + */ + xWrite(pFile, pData, iAmt, iOffsetLo, iOffsetHi) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} sizeLo + * @param {number} sizeHi + * @returns {number|Promise} + */ + xTruncate(pFile, sizeLo, sizeHi) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} flags + * @returns {number|Promise} + */ + xSync(pFile, flags) { + return SQLITE_OK; + } + + /** + * + * @param {number} pFile + * @param {number} pSize + * @returns {number|Promise} + */ + xFileSize(pFile, pSize) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} lockType + * @returns {number|Promise} + */ + xLock(pFile, lockType) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} lockType + * @returns {number|Promise} + */ + xUnlock(pFile, lockType) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} pResOut + * @returns {number|Promise} + */ + xCheckReservedLock(pFile, pResOut) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} op + * @param {number} pArg + * @returns {number|Promise} + */ + xFileControl(pFile, op, pArg) { + return SQLITE_NOTFOUND; + } + + /** + * @param {number} pFile + * @returns {number|Promise} + */ + xSectorSize(pFile) { + return DEFAULT_SECTOR_SIZE; + } + + /** + * @param {number} pFile + * @returns {number|Promise} + */ + xDeviceCharacteristics(pFile) { + return 0; + } +} + +// Copyright 2024 Roy T. Hashimoto. All Rights Reserved. + +const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor; + +// Convenience base class for a JavaScript VFS. +// The raw xOpen, xRead, etc. function signatures receive only C primitives +// which aren't easy to work with. This class provides corresponding calls +// like jOpen, jRead, etc., which receive JavaScript-friendlier arguments +// such as string, Uint8Array, and DataView. +class FacadeVFS extends Base { + /** + * @param {string} name + * @param {object} module + */ + constructor(name, module) { + super(name, module); + } + + /** + * Override to indicate which methods are asynchronous. + * @param {string} methodName + * @returns {boolean} + */ + hasAsyncMethod(methodName) { + // The input argument is a string like "xOpen", so convert to "jOpen". + // Then check if the method exists and is async. + const jMethodName = `j${methodName.slice(1)}`; + return this[jMethodName] instanceof AsyncFunction; + } + + /** + * Return the filename for a file id for use by mixins. + * @param {number} pFile + * @returns {string} + */ + getFilename(pFile) { + throw new Error('unimplemented'); + } + + /** + * @param {string?} filename + * @param {number} pFile + * @param {number} flags + * @param {DataView} pOutFlags + * @returns {number|Promise} + */ + jOpen(filename, pFile, flags, pOutFlags) { + return SQLITE_CANTOPEN; + } + + /** + * @param {string} filename + * @param {number} syncDir + * @returns {number|Promise} + */ + jDelete(filename, syncDir) { + return SQLITE_OK; + } + + /** + * @param {string} filename + * @param {number} flags + * @param {DataView} pResOut + * @returns {number|Promise} + */ + jAccess(filename, flags, pResOut) { + return SQLITE_OK; + } + + /** + * @param {string} filename + * @param {Uint8Array} zOut + * @returns {number|Promise} + */ + jFullPathname(filename, zOut) { + // Copy the filename to the output buffer. + const { read, written } = new TextEncoder().encodeInto(filename, zOut); + if (read < filename.length) return SQLITE_IOERR; + if (written >= zOut.length) return SQLITE_IOERR; + zOut[written] = 0; + return SQLITE_OK; + } + + /** + * @param {Uint8Array} zBuf + * @returns {number|Promise} + */ + jGetLastError(zBuf) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @returns {number|Promise} + */ + jClose(pFile) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {Uint8Array} pData + * @param {number} iOffset + * @returns {number|Promise} + */ + jRead(pFile, pData, iOffset) { + pData.fill(0); + return SQLITE_IOERR_SHORT_READ; + } + + /** + * @param {number} pFile + * @param {Uint8Array} pData + * @param {number} iOffset + * @returns {number|Promise} + */ + jWrite(pFile, pData, iOffset) { + return SQLITE_IOERR_WRITE; + } + + /** + * @param {number} pFile + * @param {number} size + * @returns {number|Promise} + */ + jTruncate(pFile, size) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} flags + * @returns {number|Promise} + */ + jSync(pFile, flags) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {DataView} pSize + * @returns {number|Promise} + */ + jFileSize(pFile, pSize) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} lockType + * @returns {number|Promise} + */ + jLock(pFile, lockType) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} lockType + * @returns {number|Promise} + */ + jUnlock(pFile, lockType) { + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {DataView} pResOut + * @returns {number|Promise} + */ + jCheckReservedLock(pFile, pResOut) { + pResOut.setInt32(0, 0, true); + return SQLITE_OK; + } + + /** + * @param {number} pFile + * @param {number} op + * @param {DataView} pArg + * @returns {number|Promise} + */ + jFileControl(pFile, op, pArg) { + return SQLITE_NOTFOUND; + } + + /** + * @param {number} pFile + * @returns {number|Promise} + */ + jSectorSize(pFile) { + return super.xSectorSize(pFile); + } + + /** + * @param {number} pFile + * @returns {number|Promise} + */ + jDeviceCharacteristics(pFile) { + return 0; + } + + /** + * @param {number} pVfs + * @param {number} zName + * @param {number} pFile + * @param {number} flags + * @param {number} pOutFlags + * @returns {number|Promise} + */ + xOpen(pVfs, zName, pFile, flags, pOutFlags) { + const filename = this.#decodeFilename(zName, flags); + const pOutFlagsView = this.#makeTypedDataView('Int32', pOutFlags); + this['log']?.('jOpen', filename, pFile, '0x' + flags.toString(16)); + return this.jOpen(filename, pFile, flags, pOutFlagsView); + } + + /** + * @param {number} pVfs + * @param {number} zName + * @param {number} syncDir + * @returns {number|Promise} + */ + xDelete(pVfs, zName, syncDir) { + const filename = this._module.UTF8ToString(zName); + this['log']?.('jDelete', filename, syncDir); + return this.jDelete(filename, syncDir); + } + + /** + * @param {number} pVfs + * @param {number} zName + * @param {number} flags + * @param {number} pResOut + * @returns {number|Promise} + */ + xAccess(pVfs, zName, flags, pResOut) { + const filename = this._module.UTF8ToString(zName); + const pResOutView = this.#makeTypedDataView('Int32', pResOut); + this['log']?.('jAccess', filename, flags); + return this.jAccess(filename, flags, pResOutView); + } + + /** + * @param {number} pVfs + * @param {number} zName + * @param {number} nOut + * @param {number} zOut + * @returns {number|Promise} + */ + xFullPathname(pVfs, zName, nOut, zOut) { + const filename = this._module.UTF8ToString(zName); + const zOutArray = this._module.HEAPU8.subarray(zOut, zOut + nOut); + this['log']?.('jFullPathname', filename, nOut); + return this.jFullPathname(filename, zOutArray); + } + + /** + * @param {number} pVfs + * @param {number} nBuf + * @param {number} zBuf + * @returns {number|Promise} + */ + xGetLastError(pVfs, nBuf, zBuf) { + const zBufArray = this._module.HEAPU8.subarray(zBuf, zBuf + nBuf); + this['log']?.('jGetLastError', nBuf); + return this.jGetLastError(zBufArray); + } + + /** + * @param {number} pFile + * @returns {number|Promise} + */ + xClose(pFile) { + this['log']?.('jClose', pFile); + return this.jClose(pFile); + } + + /** + * @param {number} pFile + * @param {number} pData + * @param {number} iAmt + * @param {number} iOffsetLo + * @param {number} iOffsetHi + * @returns {number|Promise} + */ + xRead(pFile, pData, iAmt, iOffsetLo, iOffsetHi) { + const pDataArray = this.#makeDataArray(pData, iAmt); + const iOffset = delegalize(iOffsetLo, iOffsetHi); + this['log']?.('jRead', pFile, iAmt, iOffset); + return this.jRead(pFile, pDataArray, iOffset); + } + + /** + * @param {number} pFile + * @param {number} pData + * @param {number} iAmt + * @param {number} iOffsetLo + * @param {number} iOffsetHi + * @returns {number|Promise} + */ + xWrite(pFile, pData, iAmt, iOffsetLo, iOffsetHi) { + const pDataArray = this.#makeDataArray(pData, iAmt); + const iOffset = delegalize(iOffsetLo, iOffsetHi); + this['log']?.('jWrite', pFile, pDataArray, iOffset); + return this.jWrite(pFile, pDataArray, iOffset); + } + + /** + * @param {number} pFile + * @param {number} sizeLo + * @param {number} sizeHi + * @returns {number|Promise} + */ + xTruncate(pFile, sizeLo, sizeHi) { + const size = delegalize(sizeLo, sizeHi); + this['log']?.('jTruncate', pFile, size); + return this.jTruncate(pFile, size); + } + + /** + * @param {number} pFile + * @param {number} flags + * @returns {number|Promise} + */ + xSync(pFile, flags) { + this['log']?.('jSync', pFile, flags); + return this.jSync(pFile, flags); + } + + /** + * + * @param {number} pFile + * @param {number} pSize + * @returns {number|Promise} + */ + xFileSize(pFile, pSize) { + const pSizeView = this.#makeTypedDataView('BigInt64', pSize); + this['log']?.('jFileSize', pFile); + return this.jFileSize(pFile, pSizeView); + } + + /** + * @param {number} pFile + * @param {number} lockType + * @returns {number|Promise} + */ + xLock(pFile, lockType) { + this['log']?.('jLock', pFile, lockType); + return this.jLock(pFile, lockType); + } + + /** + * @param {number} pFile + * @param {number} lockType + * @returns {number|Promise} + */ + xUnlock(pFile, lockType) { + this['log']?.('jUnlock', pFile, lockType); + return this.jUnlock(pFile, lockType); + } + + /** + * @param {number} pFile + * @param {number} pResOut + * @returns {number|Promise} + */ + xCheckReservedLock(pFile, pResOut) { + const pResOutView = this.#makeTypedDataView('Int32', pResOut); + this['log']?.('jCheckReservedLock', pFile); + return this.jCheckReservedLock(pFile, pResOutView); + } + + /** + * @param {number} pFile + * @param {number} op + * @param {number} pArg + * @returns {number|Promise} + */ + xFileControl(pFile, op, pArg) { + const pArgView = new DataView( + this._module.HEAPU8.buffer, + this._module.HEAPU8.byteOffset + pArg); + this['log']?.('jFileControl', pFile, op, pArgView); + return this.jFileControl(pFile, op, pArgView); + } + + /** + * @param {number} pFile + * @returns {number|Promise} + */ + xSectorSize(pFile) { + this['log']?.('jSectorSize', pFile); + return this.jSectorSize(pFile); + } + + /** + * @param {number} pFile + * @returns {number|Promise} + */ + xDeviceCharacteristics(pFile) { + this['log']?.('jDeviceCharacteristics', pFile); + return this.jDeviceCharacteristics(pFile); + } + + /** + * Wrapped DataView for pointer arguments. + * Pointers to a single value are passed using DataView. A Proxy + * wrapper prevents use of incorrect type or endianness. + * @param {'Int32'|'BigInt64'} type + * @param {number} byteOffset + * @returns {DataView} + */ + #makeTypedDataView(type, byteOffset) { + const byteLength = type === 'Int32' ? 4 : 8; + const getter = `get${type}`; + const setter = `set${type}`; + const makeDataView = () => new DataView( + this._module.HEAPU8.buffer, + this._module.HEAPU8.byteOffset + byteOffset, + byteLength); + let dataView = makeDataView(); + return new Proxy(dataView, { + get(_, prop) { + if (dataView.buffer.byteLength === 0) { + // WebAssembly memory resize detached the buffer. + dataView = makeDataView(); + } + if (prop === getter) { + return function(byteOffset, littleEndian) { + if (!littleEndian) throw new Error('must be little endian'); + return dataView[prop](byteOffset, littleEndian); + } + } + if (prop === setter) { + return function(byteOffset, value, littleEndian) { + if (!littleEndian) throw new Error('must be little endian'); + return dataView[prop](byteOffset, value, littleEndian); + } + } + if (typeof prop === 'string' && (prop.match(/^(get)|(set)/))) { + throw new Error('invalid type'); + } + const result = dataView[prop]; + return typeof result === 'function' ? result.bind(dataView) : result; + } + }); + } + + /** + * @param {number} byteOffset + * @param {number} byteLength + */ + #makeDataArray(byteOffset, byteLength) { + let target = this._module.HEAPU8.subarray(byteOffset, byteOffset + byteLength); + return new Proxy(target, { + get: (_, prop, receiver) => { + if (target.buffer.byteLength === 0) { + // WebAssembly memory resize detached the buffer. + target = this._module.HEAPU8.subarray(byteOffset, byteOffset + byteLength); + } + const result = target[prop]; + return typeof result === 'function' ? result.bind(target) : result; + } + }); + } + + #decodeFilename(zName, flags) { + if (flags & SQLITE_OPEN_URI) { + // The first null-terminated string is the URI path. Subsequent + // strings are query parameter keys and values. + // https://www.sqlite.org/c3ref/open.html#urifilenamesinsqlite3open + let pName = zName; + let state = 1; + const charCodes = []; + while (state) { + const charCode = this._module.HEAPU8[pName++]; + if (charCode) { + charCodes.push(charCode); + } else { + if (!this._module.HEAPU8[pName]) state = null; + switch (state) { + case 1: // path + charCodes.push('?'.charCodeAt(0)); + state = 2; + break; + case 2: // key + charCodes.push('='.charCodeAt(0)); + state = 3; + break; + case 3: // value + charCodes.push('&'.charCodeAt(0)); + state = 2; + break; + } + } + } + return new TextDecoder().decode(new Uint8Array(charCodes)); + } + return zName ? this._module.UTF8ToString(zName) : null; + } +} + +// Emscripten "legalizes" 64-bit integer arguments by passing them as +// two 32-bit signed integers. +function delegalize(lo32, hi32) { + return (hi32 * 0x100000000) + lo32 + (lo32 < 0 ? 2**32 : 0); +} + +// Copyright 2024 Roy T. Hashimoto. All Rights Reserved. + +const DEFAULT_TEMPORARY_FILES = 10; +const LOCK_NOTIFY_INTERVAL = 1000; + +const DB_RELATED_FILE_SUFFIXES = ['', '-journal', '-wal']; + +const finalizationRegistry = new FinalizationRegistry(releaser => releaser()); + +class File { + /** @type {string} */ path + /** @type {number} */ flags; + /** @type {FileSystemSyncAccessHandle} */ accessHandle; + + /** @type {PersistentFile?} */ persistentFile; + + constructor(path, flags) { + this.path = path; + this.flags = flags; + } +} + +class PersistentFile { + /** @type {FileSystemFileHandle} */ fileHandle + /** @type {FileSystemSyncAccessHandle} */ accessHandle = null + + // The following properties are for main database files. + + /** @type {boolean} */ isLockBusy = false; + /** @type {boolean} */ isFileLocked = false; + /** @type {boolean} */ isRequestInProgress = false; + /** @type {function} */ handleLockReleaser = null; + + /** @type {BroadcastChannel} */ handleRequestChannel; + /** @type {boolean} */ isHandleRequested = false; + + constructor(fileHandle) { + this.fileHandle = fileHandle; + } +} + +class OPFSCoopSyncVFS extends FacadeVFS { + /** @type {Map} */ mapIdToFile = new Map(); + + lastError = null; + log = null; //function(...args) { console.log(`[${contextName}]`, ...args) }; + + /** @type {Map} */ persistentFiles = new Map(); + /** @type {Map} */ boundAccessHandles = new Map(); + /** @type {Set} */ unboundAccessHandles = new Set(); + /** @type {Set} */ accessiblePaths = new Set(); + releaser = null; + + static async create(name, module) { + const vfs = new OPFSCoopSyncVFS(name, module); + await Promise.all([ + vfs.isReady(), + vfs.#initialize(DEFAULT_TEMPORARY_FILES), + ]); + return vfs; + } + + constructor(name, module) { + super(name, module); + } + + async #initialize(nTemporaryFiles) { + // Delete temporary directories no longer in use. + const root = await navigator.storage.getDirectory(); + // @ts-ignore + for await (const entry of root.values()) { + if (entry.kind === 'directory' && entry.name.startsWith('.ahp-')) { + // A lock with the same name as the directory protects it from + // being deleted. + await navigator.locks.request(entry.name, { ifAvailable: true }, async lock => { + if (lock) { + this.log?.(`Deleting temporary directory ${entry.name}`); + await root.removeEntry(entry.name, { recursive: true }); + } else { + this.log?.(`Temporary directory ${entry.name} is in use`); + } + }); + } + } + + // Create our temporary directory. + const tmpDirName = `.ahp-${Math.random().toString(36).slice(2)}`; + this.releaser = await new Promise(resolve => { + navigator.locks.request(tmpDirName, () => { + return new Promise(release => { + resolve(release); + }); + }); + }); + finalizationRegistry.register(this, this.releaser); + const tmpDir = await root.getDirectoryHandle(tmpDirName, { create: true }); + + // Populate temporary directory. + for (let i = 0; i < nTemporaryFiles; i++) { + const tmpFile = await tmpDir.getFileHandle(`${i}.tmp`, { create: true }); + const tmpAccessHandle = await tmpFile.createSyncAccessHandle(); + this.unboundAccessHandles.add(tmpAccessHandle); + } + } + + /** + * @param {string?} zName + * @param {number} fileId + * @param {number} flags + * @param {DataView} pOutFlags + * @returns {number} + */ + jOpen(zName, fileId, flags, pOutFlags) { + try { + const url = new URL(zName || Math.random().toString(36).slice(2), 'file://'); + const path = url.pathname; + + if (flags & SQLITE_OPEN_MAIN_DB) { + const persistentFile = this.persistentFiles.get(path); + if (persistentFile?.isRequestInProgress) { + // Should not reach here unless SQLite itself retries an open. + // Otherwise, asynchronous operations started on a previous + // open try should have completed. + return SQLITE_BUSY; + } else if (!persistentFile) { + // This is the usual starting point for opening a database. + // Register a Promise that resolves when the database and related + // files are ready to be used. + this.log?.(`creating persistent file for ${path}`); + const create = !!(flags & SQLITE_OPEN_CREATE); + this._module.retryOps.push((async () => { + try { + // Get the path directory handle. + let dirHandle = await navigator.storage.getDirectory(); + const directories = path.split('/').filter(d => d); + const filename = directories.pop(); + for (const directory of directories) { + dirHandle = await dirHandle.getDirectoryHandle(directory, { create }); + } + + // Get file handles for the database and related files, + // and create persistent file instances. + for (const suffix of DB_RELATED_FILE_SUFFIXES) { + const fileHandle = await dirHandle.getFileHandle(filename + suffix, { create }); + await this.#createPersistentFile(fileHandle); + } + + // Get access handles for the files. + const file = new File(path, flags); + file.persistentFile = this.persistentFiles.get(path); + await this.#requestAccessHandle(file); + } catch (e) { + // Use an invalid persistent file to signal this error + // for the retried open. + const persistentFile = new PersistentFile(null); + this.persistentFiles.set(path, persistentFile); + console.error(e); + } + })()); + return SQLITE_BUSY; + } else if (!persistentFile.fileHandle) { + // The asynchronous open operation failed. + this.persistentFiles.delete(path); + return SQLITE_CANTOPEN; + } else if (!persistentFile.accessHandle) { + // This branch is reached if the database was previously opened + // and closed. + this._module.retryOps.push((async () => { + const file = new File(path, flags); + file.persistentFile = this.persistentFiles.get(path); + await this.#requestAccessHandle(file); + })()); + return SQLITE_BUSY; + } + } + + if (!this.accessiblePaths.has(path) && + !(flags & SQLITE_OPEN_CREATE)) { + throw new Error(`File ${path} not found`); + } + + const file = new File(path, flags); + this.mapIdToFile.set(fileId, file); + + if (this.persistentFiles.has(path)) { + file.persistentFile = this.persistentFiles.get(path); + } else if (this.boundAccessHandles.has(path)) { + // This temporary file was previously created and closed. Reopen + // the same access handle. + file.accessHandle = this.boundAccessHandles.get(path); + } else if (this.unboundAccessHandles.size) { + // Associate an unbound access handle to this file. + file.accessHandle = this.unboundAccessHandles.values().next().value; + file.accessHandle.truncate(0); + this.unboundAccessHandles.delete(file.accessHandle); + this.boundAccessHandles.set(path, file.accessHandle); + } + this.accessiblePaths.add(path); + + pOutFlags.setInt32(0, flags, true); + return SQLITE_OK; + } catch (e) { + this.lastError = e; + return SQLITE_CANTOPEN; + } + } + + /** + * @param {string} zName + * @param {number} syncDir + * @returns {number} + */ + jDelete(zName, syncDir) { + try { + const url = new URL(zName, 'file://'); + const path = url.pathname; + if (this.persistentFiles.has(path)) { + const persistentFile = this.persistentFiles.get(path); + persistentFile.accessHandle.truncate(0); + } else { + this.boundAccessHandles.get(path)?.truncate(0); + } + this.accessiblePaths.delete(path); + return SQLITE_OK; + } catch (e) { + this.lastError = e; + return SQLITE_IOERR_DELETE; + } + } + + /** + * @param {string} zName + * @param {number} flags + * @param {DataView} pResOut + * @returns {number} + */ + jAccess(zName, flags, pResOut) { + try { + const url = new URL(zName, 'file://'); + const path = url.pathname; + pResOut.setInt32(0, this.accessiblePaths.has(path) ? 1 : 0, true); + return SQLITE_OK; + } catch (e) { + this.lastError = e; + return SQLITE_IOERR_ACCESS; + } + } + + /** + * @param {number} fileId + * @returns {number} + */ + jClose(fileId) { + try { + const file = this.mapIdToFile.get(fileId); + this.mapIdToFile.delete(fileId); + + if (file?.flags & SQLITE_OPEN_MAIN_DB) { + if (file.persistentFile?.handleLockReleaser) { + this.#releaseAccessHandle(file); + } + } else if (file?.flags & SQLITE_OPEN_DELETEONCLOSE) { + file.accessHandle.truncate(0); + this.accessiblePaths.delete(file.path); + if (!this.persistentFiles.has(file.path)) { + this.boundAccessHandles.delete(file.path); + this.unboundAccessHandles.add(file.accessHandle); + } + } + return SQLITE_OK; + } catch (e) { + this.lastError = e; + return SQLITE_IOERR_CLOSE; + } + } + + /** + * @param {number} fileId + * @param {Uint8Array} pData + * @param {number} iOffset + * @returns {number} + */ + jRead(fileId, pData, iOffset) { + try { + const file = this.mapIdToFile.get(fileId); + + // On Chrome (at least), passing pData to accessHandle.read() is + // an error because pData is a Proxy of a Uint8Array. Calling + // subarray() produces a real Uint8Array and that works. + const accessHandle = file.accessHandle || file.persistentFile.accessHandle; + const bytesRead = accessHandle.read(pData.subarray(), { at: iOffset }); + + // Opening a database file performs one read without a xLock call. + if ((file.flags & SQLITE_OPEN_MAIN_DB) && !file.persistentFile.isFileLocked) { + this.#releaseAccessHandle(file); + } + + if (bytesRead < pData.byteLength) { + pData.fill(0, bytesRead); + return SQLITE_IOERR_SHORT_READ; + } + return SQLITE_OK; + } catch (e) { + this.lastError = e; + return SQLITE_IOERR_READ; + } + } + + /** + * @param {number} fileId + * @param {Uint8Array} pData + * @param {number} iOffset + * @returns {number} + */ + jWrite(fileId, pData, iOffset) { + try { + const file = this.mapIdToFile.get(fileId); + + // On Chrome (at least), passing pData to accessHandle.write() is + // an error because pData is a Proxy of a Uint8Array. Calling + // subarray() produces a real Uint8Array and that works. + const accessHandle = file.accessHandle || file.persistentFile.accessHandle; + const nBytes = accessHandle.write(pData.subarray(), { at: iOffset }); + if (nBytes !== pData.byteLength) throw new Error('short write'); + return SQLITE_OK; + } catch (e) { + this.lastError = e; + return SQLITE_IOERR_WRITE; + } + } + + /** + * @param {number} fileId + * @param {number} iSize + * @returns {number} + */ + jTruncate(fileId, iSize) { + try { + const file = this.mapIdToFile.get(fileId); + const accessHandle = file.accessHandle || file.persistentFile.accessHandle; + accessHandle.truncate(iSize); + return SQLITE_OK; + } catch (e) { + this.lastError = e; + return SQLITE_IOERR_TRUNCATE; + } + } + + /** + * @param {number} fileId + * @param {number} flags + * @returns {number} + */ + jSync(fileId, flags) { + try { + const file = this.mapIdToFile.get(fileId); + const accessHandle = file.accessHandle || file.persistentFile.accessHandle; + accessHandle.flush(); + return SQLITE_OK; + } catch (e) { + this.lastError = e; + return SQLITE_IOERR_FSYNC; + } + } + + /** + * @param {number} fileId + * @param {DataView} pSize64 + * @returns {number} + */ + jFileSize(fileId, pSize64) { + try { + const file = this.mapIdToFile.get(fileId); + const accessHandle = file.accessHandle || file.persistentFile.accessHandle; + const size = accessHandle.getSize(); + pSize64.setBigInt64(0, BigInt(size), true); + return SQLITE_OK; + } catch (e) { + this.lastError = e; + return SQLITE_IOERR_FSTAT; + } + } + + /** + * @param {number} fileId + * @param {number} lockType + * @returns {number} + */ + jLock(fileId, lockType) { + const file = this.mapIdToFile.get(fileId); + if (file.persistentFile.isRequestInProgress) { + file.persistentFile.isLockBusy = true; + return SQLITE_BUSY; + } + + file.persistentFile.isFileLocked = true; + if (!file.persistentFile.handleLockReleaser) { + // Start listening for notifications from other connections. + // This is before we actually get access handles, but waiting to + // listen until then allows a race condition where notifications + // are missed. + file.persistentFile.handleRequestChannel.onmessage = () => { + this.log?.(`received notification for ${file.path}`); + if (file.persistentFile.isFileLocked) { + // We're still using the access handle, so mark it to be + // released when we're done. + file.persistentFile.isHandleRequested = true; + } else { + // Release the access handles immediately. + this.#releaseAccessHandle(file); + } + file.persistentFile.handleRequestChannel.onmessage = null; + }; + + this.#requestAccessHandle(file); + this.log?.('returning SQLITE_BUSY'); + file.persistentFile.isLockBusy = true; + return SQLITE_BUSY; + } + file.persistentFile.isLockBusy = false; + return SQLITE_OK; + } + + /** + * @param {number} fileId + * @param {number} lockType + * @returns {number} + */ + jUnlock(fileId, lockType) { + const file = this.mapIdToFile.get(fileId); + if (lockType === SQLITE_LOCK_NONE) { + // Don't change any state if this unlock is because xLock returned + // SQLITE_BUSY. + if (!file.persistentFile.isLockBusy) { + if (file.persistentFile.isHandleRequested) { + // Another connection wants the access handle. + this.#releaseAccessHandle(file); + this.isHandleRequested = false; + } + file.persistentFile.isFileLocked = false; + } + } + return SQLITE_OK; + } + + /** + * @param {number} fileId + * @param {number} op + * @param {DataView} pArg + * @returns {number|Promise} + */ + jFileControl(fileId, op, pArg) { + try { + const file = this.mapIdToFile.get(fileId); + switch (op) { + case SQLITE_FCNTL_PRAGMA: + const key = extractString(pArg, 4); + const value = extractString(pArg, 8); + this.log?.('xFileControl', file.path, 'PRAGMA', key, value); + switch (key.toLowerCase()) { + case 'journal_mode': + if (value && + !['off', 'memory', 'delete', 'wal'].includes(value.toLowerCase())) { + throw new Error('journal_mode must be "off", "memory", "delete", or "wal"'); + } + break; + } + break; + } + } catch (e) { + this.lastError = e; + return SQLITE_IOERR; + } + return SQLITE_NOTFOUND; + } + + /** + * @param {Uint8Array} zBuf + * @returns + */ + jGetLastError(zBuf) { + if (this.lastError) { + console.error(this.lastError); + const outputArray = zBuf.subarray(0, zBuf.byteLength - 1); + const { written } = new TextEncoder().encodeInto(this.lastError.message, outputArray); + zBuf[written] = 0; + } + return SQLITE_OK + } + + /** + * @param {FileSystemFileHandle} fileHandle + * @returns {Promise} + */ + async #createPersistentFile(fileHandle) { + const persistentFile = new PersistentFile(fileHandle); + const root = await navigator.storage.getDirectory(); + const relativePath = await root.resolve(fileHandle); + const path = `/${relativePath.join('/')}`; + persistentFile.handleRequestChannel = new BroadcastChannel(`ahp:${path}`); + this.persistentFiles.set(path, persistentFile); + + const f = await fileHandle.getFile(); + if (f.size) { + this.accessiblePaths.add(path); + } + return persistentFile; + } + + /** + * @param {File} file + */ + #requestAccessHandle(file) { + console.assert(!file.persistentFile.handleLockReleaser); + if (!file.persistentFile.isRequestInProgress) { + file.persistentFile.isRequestInProgress = true; + this._module.retryOps.push((async () => { + // Acquire the Web Lock. + file.persistentFile.handleLockReleaser = await this.#acquireLock(file.persistentFile); + + // Get access handles for the database and releated files in parallel. + this.log?.(`creating access handles for ${file.path}`); + await Promise.all(DB_RELATED_FILE_SUFFIXES.map(async suffix => { + const persistentFile = this.persistentFiles.get(file.path + suffix); + if (persistentFile) { + persistentFile.accessHandle = + await persistentFile.fileHandle.createSyncAccessHandle(); + } + })); + file.persistentFile.isRequestInProgress = false; + })()); + return this._module.retryOps.at(-1); + } + return Promise.resolve(); + } + + /** + * @param {File} file + */ + async #releaseAccessHandle(file) { + DB_RELATED_FILE_SUFFIXES.forEach(async suffix => { + const persistentFile = this.persistentFiles.get(file.path + suffix); + if (persistentFile) { + persistentFile.accessHandle?.close(); + persistentFile.accessHandle = null; + } + }); + this.log?.(`access handles closed for ${file.path}`); + + file.persistentFile.handleLockReleaser?.(); + file.persistentFile.handleLockReleaser = null; + this.log?.(`lock released for ${file.path}`); + } + + /** + * @param {PersistentFile} persistentFile + * @returns {Promise} lock releaser + */ + #acquireLock(persistentFile) { + return new Promise(resolve => { + // Tell other connections we want the access handle. + const lockName = persistentFile.handleRequestChannel.name; + const notify = () => { + this.log?.(`notifying for ${lockName}`); + persistentFile.handleRequestChannel.postMessage(null); + }; + const notifyId = setInterval(notify, LOCK_NOTIFY_INTERVAL); + setTimeout(notify); + + this.log?.(`lock requested: ${lockName}`); + navigator.locks.request(lockName, lock => { + // We have the lock. Stop asking other connections for it. + this.log?.(`lock acquired: ${lockName}`, lock); + clearInterval(notifyId); + return new Promise(resolve); + }); + }); + } +} + +function extractString(dataView, offset) { + const p = dataView.getUint32(offset, true); + if (p) { + const chars = new Uint8Array(dataView.buffer, p); + return new TextDecoder().decode(chars.subarray(0, chars.indexOf(0))); + } + return null; +} + var Module = (() => { var _scriptName = import.meta.url; @@ -1414,7 +2721,7 @@ class SQLite { if (typeof module === "undefined") { throw new Error("Cannot be called directly"); } - + this.module = module; this.sqlite3 = Factory(module); } @@ -1458,10 +2765,13 @@ class SQLite { async open_v2(database_url, iflags) { try { console.log("Opening database!", database_url); + const vfs = await OPFSCoopSyncVFS.create(database_url, this.module); + this.sqlite3.vfs_register(vfs, true); let db = await this.sqlite3.open_v2(database_url, iflags); return db; - } catch { - console.log("openv2 error"); + } catch (error) { + console.log("openv2 error", error); + throw error; } } diff --git a/diesel-wasm-sqlite/tests/web.rs b/diesel-wasm-sqlite/tests/web.rs index 0305c809d..dcd07b536 100755 --- a/diesel-wasm-sqlite/tests/web.rs +++ b/diesel-wasm-sqlite/tests/web.rs @@ -15,7 +15,8 @@ async fn test_establish() { rng ); */ - let mut conn = WasmSqliteConnection::establish("test").await.unwrap(); + let mut result = WasmSqliteConnection::establish("test").await; + let mut conn = result.unwrap(); console::log_1(&"CONNECTED".into()); // assert 1 == 2 is here b/c can't get --nocapture to work yet assert_eq!(1, 2); From 45a8175832a58dae51c6ccedf9fe1e562bccbef4 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Wed, 31 Jul 2024 14:28:39 -0400 Subject: [PATCH 13/28] register fn --- diesel-wasm-sqlite/package.js | 24 +++- diesel-wasm-sqlite/src/connection/mod.rs | 3 +- diesel-wasm-sqlite/src/connection/raw.rs | 146 ++++++++--------------- diesel-wasm-sqlite/src/ffi.rs | 12 ++ diesel-wasm-sqlite/src/package.js | 24 +++- diesel-wasm-sqlite/src/sqlite_types.rs | 19 +++ 6 files changed, 123 insertions(+), 105 deletions(-) diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index fa551d9dc..225640279 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -62,7 +62,7 @@ export class SQLite { result_null(context) { this.sqlite3.result_null(context); } - + async open_v2(database_url, iflags) { try { console.log("Opening database!", database_url); @@ -75,12 +75,12 @@ export class SQLite { throw error; } } - + async exec(db, query) { try { return await this.sqlite3.exec(db, query); } catch { - console.log('exec err'); + console.log("exec err"); } } @@ -96,4 +96,22 @@ export class SQLite { console.log("exec err"); } } + + create_function(database, functionName, nArg, textRep, xFunc, xStep, xFinal) { + try { + sqlite.create_function( + database, + functionName, + nArg, + textRep, + 0, + xFunc, + xStep, + xFinal, + ); + console.log("create function"); + } catch { + console.log("create function err"); + } + } } diff --git a/diesel-wasm-sqlite/src/connection/mod.rs b/diesel-wasm-sqlite/src/connection/mod.rs index 86d8bede3..8061d32c2 100644 --- a/diesel-wasm-sqlite/src/connection/mod.rs +++ b/diesel-wasm-sqlite/src/connection/mod.rs @@ -50,7 +50,7 @@ use std::future::Ready; unsafe impl Send for WasmSqliteConnection {} #[derive(Debug)] pub struct WasmSqliteConnection { - raw: raw::RawConnection, + pub raw: raw::RawConnection, } #[async_trait::async_trait(?Send)] @@ -64,7 +64,6 @@ impl SimpleAsyncConnection for WasmSqliteConnection { } /// TODO: The placeholder stuff all needs to be re-done - pub struct OwnedSqliteFieldPlaceholder<'field> { field: PhantomData<&'field ()>, } diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs index a8fd17e36..0ea58dc13 100644 --- a/diesel-wasm-sqlite/src/connection/raw.rs +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -12,11 +12,14 @@ // use super::{Sqlite, SqliteAggregateFunction}; // use crate::deserialize::FromSqlRow; // use crate::result::Error::DatabaseError; -use crate::{sqlite_types::SqliteOpenFlags, WasmSqliteError}; +use crate::{ + sqlite_types::{SqliteFlags, SqliteOpenFlags}, + WasmSqlite, WasmSqliteError, +}; use diesel::result::*; use diesel::serialize::ToSql; use diesel::sql_types::HasSqlType; -use wasm_bindgen::JsValue; +use wasm_bindgen::{closure::Closure, JsValue}; /* /// For use in FFI function, which cannot unwind. /// Print the message, ask to open an issue at Github and [`abort`](std::process::abort). @@ -33,7 +36,7 @@ macro_rules! assert_fail { */ #[allow(missing_copy_implementations)] -#[derive(Debug)] +#[derive(Clone, Debug)] pub(super) struct RawConnection { pub(super) internal_connection: JsValue, } @@ -74,46 +77,35 @@ impl RawConnection { sqlite3.changes(&self.internal_connection) } - /* - pub(super) fn register_sql_function( + pub(super) fn register_sql_function( &self, fn_name: &str, - num_args: usize, + num_args: i32, deterministic: bool, - f: F, + mut f: F, ) -> QueryResult<()> where - F: FnMut(&Self, &mut [*mut ffi::sqlite3_value]) -> QueryResult - + std::panic::UnwindSafe - + Send - + 'static, - Ret: ToSql, - Sqlite: HasSqlType, + F: FnMut(JsValue, JsValue) + 'static, { - let callback_fn = Box::into_raw(Box::new(CustomFunctionUserPtr { - callback: f, - function_name: fn_name.to_owned(), - })); - let fn_name = Self::get_fn_name(fn_name)?; + let sqlite3 = crate::get_sqlite_unchecked(); let flags = Self::get_flags(deterministic); - let result = unsafe { - ffi::sqlite3_create_function_v2( - self.internal_connection.as_ptr(), - fn_name.as_ptr(), - num_args as _, + let cb = Closure::new(f); + sqlite3 + .create_function( + &self.internal_connection, + fn_name, + num_args, flags, - callback_fn as *mut _, - Some(run_custom_function::), + Some(&cb), None, None, - Some(destroy_boxed::>), ) - }; - - Self::process_sql_function_result(result) + .unwrap(); + Ok(()) } + /* pub(super) fn register_aggregate_function( &self, fn_name: &str, @@ -206,19 +198,17 @@ impl RawConnection { ensure_sqlite_ok(result, self.internal_connection.as_ptr()) } } - - fn get_fn_name(fn_name: &str) -> Result { - CString::new(fn_name) - } + */ fn get_flags(deterministic: bool) -> i32 { - let mut flags = ffi::SQLITE_UTF8; + let mut flags = SqliteFlags::SQLITE_UTF8; if deterministic { - flags |= ffi::SQLITE_DETERMINISTIC; + flags |= SqliteFlags::SQLITE_DETERMINISTIC; } - flags + flags.bits() as i32 } + /* fn process_sql_function_result(result: i32) -> Result<(), Error> { if result == ffi::SQLITE_OK { Ok(()) @@ -288,68 +278,9 @@ struct CustomFunctionUserPtr { callback: F, function_name: String, } +*/ -#[allow(warnings)] -extern "C" fn run_custom_function( - ctx: *mut ffi::sqlite3_context, - num_args: libc::c_int, - value_ptr: *mut *mut ffi::sqlite3_value, -) where - F: FnMut(&RawConnection, &mut [*mut ffi::sqlite3_value]) -> QueryResult - + std::panic::UnwindSafe - + Send - + 'static, - Ret: ToSql, - Sqlite: HasSqlType, -{ - use std::ops::Deref; - static NULL_DATA_ERR: &str = "An unknown error occurred. sqlite3_user_data returned a null pointer. This should never happen."; - static NULL_CONN_ERR: &str = "An unknown error occurred. sqlite3_context_db_handle returned a null pointer. This should never happen."; - - let conn = match unsafe { NonNull::new(ffi::sqlite3_context_db_handle(ctx)) } { - // We use `ManuallyDrop` here because we do not want to run the - // Drop impl of `RawConnection` as this would close the connection - Some(conn) => mem::ManuallyDrop::new(RawConnection { - internal_connection: conn, - }), - None => { - unsafe { context_error_str(ctx, NULL_CONN_ERR) }; - return; - } - }; - - let data_ptr = unsafe { ffi::sqlite3_user_data(ctx) }; - - let mut data_ptr = match NonNull::new(data_ptr as *mut CustomFunctionUserPtr) { - None => unsafe { - context_error_str(ctx, NULL_DATA_ERR); - return; - }, - Some(mut f) => f, - }; - let data_ptr = unsafe { data_ptr.as_mut() }; - - // We need this to move the reference into the catch_unwind part - // this is sound as `F` itself and the stored string is `UnwindSafe` - let callback = std::panic::AssertUnwindSafe(&mut data_ptr.callback); - - let result = std::panic::catch_unwind(move || { - let _ = &callback; - let args = unsafe { slice::from_raw_parts_mut(value_ptr, num_args as _) }; - let res = (callback.0)(&*conn, args)?; - let value = process_sql_function_result(&res)?; - // We've checked already that ctx is not null - unsafe { - value.result_of(&mut *ctx); - } - Ok(()) - }) - .unwrap_or_else(|p| Err(SqliteCallbackError::Panic(data_ptr.function_name.clone()))); - if let Err(e) = result { - e.emit(ctx); - } -} - +/* // Need a custom option type here, because the std lib one does not have guarantees about the discriminate values // See: https://github.com/rust-lang/rfcs/blob/master/text/2195-really-tagged-unions.md#opaque-tags #[repr(u8)] @@ -604,3 +535,24 @@ extern "C" fn destroy_boxed(data: *mut libc::c_void) { unsafe { std::mem::drop(Box::from_raw(ptr)) }; } */ + +#[cfg(test)] +mod tests { + use super::*; + use crate::connection::{AsyncConnection, WasmSqliteConnection}; + use diesel::connection::Connection; + use wasm_bindgen_test::*; + use web_sys::console; + wasm_bindgen_test_configure!(run_in_dedicated_worker); + + #[wasm_bindgen_test] + async fn test_fn_registration() { + let mut result = WasmSqliteConnection::establish("test").await; + let mut conn = result.unwrap(); + console::log_1(&"CONNECTED".into()); + conn.raw + .register_sql_function("test", 0, true, |ctx, values| { + console::log_1(&"Inside Fn".into()); + }); + } +} diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index c6c62da27..05765afad 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -63,6 +63,18 @@ extern "C" { #[wasm_bindgen(method, catch)] pub fn batch_execute(this: &SQLite, database: &JsValue, query: &str) -> Result<(), JsValue>; + + #[wasm_bindgen(method, catch)] + pub fn create_function( + this: &SQLite, + database: &JsValue, + functionName: &str, + n_arg: i32, + textRep: i32, + x_func: Option<&Closure>, + x_step: Option<&Closure>, + x_final: Option<&Closure>, + ) -> Result<(), JsValue>; } impl std::fmt::Debug for SQLite { diff --git a/diesel-wasm-sqlite/src/package.js b/diesel-wasm-sqlite/src/package.js index 45273a68f..4a11058de 100644 --- a/diesel-wasm-sqlite/src/package.js +++ b/diesel-wasm-sqlite/src/package.js @@ -2761,7 +2761,7 @@ class SQLite { result_null(context) { this.sqlite3.result_null(context); } - + async open_v2(database_url, iflags) { try { console.log("Opening database!", database_url); @@ -2774,12 +2774,12 @@ class SQLite { throw error; } } - + async exec(db, query) { try { return await this.sqlite3.exec(db, query); } catch { - console.log('exec err'); + console.log("exec err"); } } @@ -2795,6 +2795,24 @@ class SQLite { console.log("exec err"); } } + + create_function(database, functionName, nArg, textRep, xFunc, xStep, xFinal) { + try { + sqlite.create_function( + database, + functionName, + nArg, + textRep, + 0, + xFunc, + xStep, + xFinal, + ); + console.log("create function"); + } catch { + console.log("create function err"); + } + } } export { SQLite }; diff --git a/diesel-wasm-sqlite/src/sqlite_types.rs b/diesel-wasm-sqlite/src/sqlite_types.rs index a9f1838f7..c9ede3420 100644 --- a/diesel-wasm-sqlite/src/sqlite_types.rs +++ b/diesel-wasm-sqlite/src/sqlite_types.rs @@ -51,3 +51,22 @@ bitflags! { const SQLITE_OPEN_EXRESCODE = 0x02000000; /* Extended result codes */ } } + +/// SQLite Text Encodings https://www.sqlite.org/capi3ref.html#SQLITE_ANY +bitflags! { + pub struct SqliteFlags: u32 { + const SQLITE_UTF8 = 1; /* IMP: R-37514-35566 */ + const SQLITE_UTF16LE = 2; /* IMP: R-03371-37637 */ + const SQLITE_UTF16BE = 3; /* IMP: R-51971-34154 */ + const SQLITE_UTF16 = 4; /* Use native byte order */ + const SQLITE_ANY = 5; /* Deprecated */ + const SQLITE_UTF16_ALIGNED = 8; /* sqlite3_create_collation only */ + + /// SQLite Function Flags https://www.sqlite.org/capi3ref.html#sqlitedeterministic + const SQLITE_DETERMINISTIC = 0x000000800; + const SQLITE_DIRECTONLY = 0x000080000; + const SQLITE_SUBTYPE = 0x000100000; + const SQLITE_INNOCUOUS = 0x000200000; + const SQLITE_RESULT_SUBTYPE = 0x001000000; + } +} From 8b9f533b896756bdf41933992a444e4cc4065e47 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Mon, 5 Aug 2024 17:47:26 -0400 Subject: [PATCH 14/28] porting stmt, then sqlite_value --- Cargo.lock | 96 +-- Cargo.toml | 3 +- diesel-wasm-sqlite/.vscode/settings.json | 32 + diesel-wasm-sqlite/Cargo.lock | 697 ++++++++++++++++ diesel-wasm-sqlite/Cargo.toml | 5 + diesel-wasm-sqlite/README.md | 6 + diesel-wasm-sqlite/package-lock.json | 756 ++++++++++++++++++ diesel-wasm-sqlite/package.js | 110 +++ diesel-wasm-sqlite/src/backend.rs | 6 +- .../src/connection/bind_collector.rs | 24 +- diesel-wasm-sqlite/src/connection/mod.rs | 8 +- .../src/connection/owned_row.rs | 14 +- diesel-wasm-sqlite/src/connection/raw.rs | 379 +-------- diesel-wasm-sqlite/src/connection/row.rs | 26 +- .../src/connection/sqlite_value.rs | 42 +- diesel-wasm-sqlite/src/connection/stmt.rs | 158 ++-- diesel-wasm-sqlite/src/ffi.rs | 67 ++ diesel-wasm-sqlite/src/lib.rs | 6 +- diesel-wasm-sqlite/src/package.js | 39 + diesel-wasm-sqlite/src/sqlite_types.rs | 19 +- 20 files changed, 1865 insertions(+), 628 deletions(-) create mode 100644 diesel-wasm-sqlite/.vscode/settings.json create mode 100644 diesel-wasm-sqlite/Cargo.lock create mode 100644 diesel-wasm-sqlite/package-lock.json diff --git a/Cargo.lock b/Cargo.lock index c29df6d2e..6f5b50da0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1066,72 +1066,19 @@ name = "diesel" version = "2.2.0" source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ - "diesel_derives 2.2.0", + "diesel_derives", "libsqlite3-sys", "r2d2", "time", ] -[[package]] -name = "diesel" -version = "2.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf97ee7261bb708fa3402fa9c17a54b70e90e3cb98afb3dc8999d5512cb03f94" -dependencies = [ - "diesel_derives 2.2.2", -] - -[[package]] -name = "diesel-async" -version = "0.5.0" -source = "git+https://github.com/insipx/diesel_async?branch=insipx/wasm-async#c255cddfecec3597fb102cfa85494f6e23cb6b9b" -dependencies = [ - "async-trait", - "diesel 2.2.2", - "futures-util", - "scoped-futures", -] - -[[package]] -name = "diesel-wasm-sqlite" -version = "0.1.1" -dependencies = [ - "async-trait", - "bitflags 2.6.0", - "console_error_panic_hook", - "diesel 2.2.2", - "diesel-async", - "futures", - "getrandom", - "log", - "rand", - "tokio", - "wasm-bindgen", - "wasm-bindgen-futures", - "wasm-bindgen-test", - "web-sys", -] - [[package]] name = "diesel_derives" version = "2.2.0" source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ - "diesel_table_macro_syntax 0.2.0 (git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend)", - "dsl_auto_type 0.1.0", - "proc-macro2", - "quote", - "syn 2.0.71", -] - -[[package]] -name = "diesel_derives" -version = "2.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d6ff2be1e7312c858b2ef974f5c7089833ae57b5311b334b30923af58e5718d8" -dependencies = [ - "diesel_table_macro_syntax 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", - "dsl_auto_type 0.1.2", + "diesel_table_macro_syntax", + "dsl_auto_type", "proc-macro2", "quote", "syn 2.0.71", @@ -1142,20 +1089,11 @@ name = "diesel_migrations" version = "2.2.0" source = "git+https://github.com/xmtp/diesel?branch=insipx/wasm-backend#a3fa32d4291bbae566cf544ca63a1aa2543da943" dependencies = [ - "diesel 2.2.0", + "diesel", "migrations_internals", "migrations_macros", ] -[[package]] -name = "diesel_table_macro_syntax" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" -dependencies = [ - "syn 2.0.71", -] - [[package]] name = "diesel_table_macro_syntax" version = "0.2.0" @@ -1252,20 +1190,6 @@ dependencies = [ "syn 2.0.71", ] -[[package]] -name = "dsl_auto_type" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5d9abe6314103864cc2d8901b7ae224e0ab1a103a0a416661b4097b0779b607" -dependencies = [ - "darling", - "either", - "heck 0.5.0", - "proc-macro2", - "quote", - "syn 2.0.71", -] - [[package]] name = "dunce" version = "1.0.4" @@ -4735,16 +4659,6 @@ dependencies = [ "parking_lot 0.12.3", ] -[[package]] -name = "scoped-futures" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1473e24c637950c9bd38763220bea91ec3e095a89f672bbd7a10d03e77ba467" -dependencies = [ - "cfg-if", - "pin-utils", -] - [[package]] name = "scoped-tls" version = "1.0.1" @@ -6653,7 +6567,7 @@ dependencies = [ "chrono", "criterion", "ctor", - "diesel 2.2.0", + "diesel", "diesel_migrations", "ed25519-dalek", "ethers", diff --git a/Cargo.toml b/Cargo.toml index 78f19303c..892323ebf 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,7 +9,7 @@ members = [ "xmtp_user_preferences", "xmtp_v2", "xmtp_mls", - "xmtp_id", "diesel-wasm-sqlite" + "xmtp_id" ] exclude = [ @@ -17,6 +17,7 @@ exclude = [ "bindings_wasm", "xmtp_api_grpc_gateway", "bindings_node", + "diesel-wasm-sqlite" ] # Make the feature resolver explicit. diff --git a/diesel-wasm-sqlite/.vscode/settings.json b/diesel-wasm-sqlite/.vscode/settings.json new file mode 100644 index 000000000..cb6099b62 --- /dev/null +++ b/diesel-wasm-sqlite/.vscode/settings.json @@ -0,0 +1,32 @@ +{ + "rust-analyzer": { + "cargo": { + "sysroot": "discover", + "allTargets": false, + "target": "wasm32-unknown-unknown" + }, + "procMacro": { + "enable": true, + "attributes.enable": true, + "ignored": { + "async-trait": ["async_trait"], + "napi-derive": ["napi"], + "async-recursion": ["async_recursion"], + "ctor": ["ctor"], + "tokio": ["test"] + } + } + }, + "[toml]": { + "editor.defaultFormatter": "tamasfe.even-better-toml" + }, + "[typescript]": { + "editor.defaultFormatter": "esbenp.prettier-vscode" + }, + "[javascript]": { + "editor.defaultFormatter": "esbenp.prettier-vscode" + }, + "[json]": { + "editor.defaultFormatter": "esbenp.prettier-vscode" + } +} diff --git a/diesel-wasm-sqlite/Cargo.lock b/diesel-wasm-sqlite/Cargo.lock new file mode 100644 index 000000000..171c620d6 --- /dev/null +++ b/diesel-wasm-sqlite/Cargo.lock @@ -0,0 +1,697 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "addr2line" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" + +[[package]] +name = "async-trait" +version = "0.1.81" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e0c28dcc82d7c8ead5cb13beb15405b57b8546e93215673ff8ca0349a028107" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "autocfg" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" + +[[package]] +name = "backtrace" +version = "0.3.73" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a" +dependencies = [ + "addr2line", + "cc", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", +] + +[[package]] +name = "bitflags" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" + +[[package]] +name = "bumpalo" +version = "3.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50" + +[[package]] +name = "cc" +version = "1.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26a5c3fd7bfa1ce3897a3a3501d362b2d87b7f2583ebcb4a949ec25911025cbc" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "console_error_panic_hook" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" +dependencies = [ + "cfg-if", + "wasm-bindgen", +] + +[[package]] +name = "darling" +version = "0.20.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989" +dependencies = [ + "darling_core", + "darling_macro", +] + +[[package]] +name = "darling_core" +version = "0.20.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5" +dependencies = [ + "fnv", + "ident_case", + "proc-macro2", + "quote", + "strsim", + "syn", +] + +[[package]] +name = "darling_macro" +version = "0.20.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806" +dependencies = [ + "darling_core", + "quote", + "syn", +] + +[[package]] +name = "diesel" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf97ee7261bb708fa3402fa9c17a54b70e90e3cb98afb3dc8999d5512cb03f94" +dependencies = [ + "diesel_derives", +] + +[[package]] +name = "diesel-async" +version = "0.5.0" +source = "git+https://github.com/insipx/diesel_async?branch=insipx/wasm-async#c255cddfecec3597fb102cfa85494f6e23cb6b9b" +dependencies = [ + "async-trait", + "diesel", + "futures-util", + "scoped-futures", +] + +[[package]] +name = "diesel-wasm-sqlite" +version = "0.1.1" +dependencies = [ + "async-trait", + "bitflags", + "console_error_panic_hook", + "diesel", + "diesel-async", + "futures", + "getrandom", + "log", + "rand", + "serde", + "serde-wasm-bindgen", + "tokio", + "wasm-bindgen", + "wasm-bindgen-futures", + "wasm-bindgen-test", + "web-sys", +] + +[[package]] +name = "diesel_derives" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6ff2be1e7312c858b2ef974f5c7089833ae57b5311b334b30923af58e5718d8" +dependencies = [ + "diesel_table_macro_syntax", + "dsl_auto_type", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "diesel_table_macro_syntax" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" +dependencies = [ + "syn", +] + +[[package]] +name = "dsl_auto_type" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5d9abe6314103864cc2d8901b7ae224e0ab1a103a0a416661b4097b0779b607" +dependencies = [ + "darling", + "either", + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "either" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "futures" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" + +[[package]] +name = "futures-executor" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1" + +[[package]] +name = "futures-macro" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "futures-sink" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5" + +[[package]] +name = "futures-task" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" + +[[package]] +name = "futures-util" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "getrandom" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi", + "wasm-bindgen", +] + +[[package]] +name = "gimli" +version = "0.29.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "ident_case" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" + +[[package]] +name = "js-sys" +version = "0.3.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d" +dependencies = [ + "wasm-bindgen", +] + +[[package]] +name = "libc" +version = "0.2.155" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" + +[[package]] +name = "log" +version = "0.4.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" + +[[package]] +name = "memchr" +version = "2.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" + +[[package]] +name = "miniz_oxide" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08" +dependencies = [ + "adler", +] + +[[package]] +name = "object" +version = "0.36.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f203fa8daa7bb185f760ae12bd8e097f63d17041dcdcaf675ac54cdf863170e" +dependencies = [ + "memchr", +] + +[[package]] +name = "once_cell" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" + +[[package]] +name = "pin-project-lite" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "ppv-lite86" +version = "0.2.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "proc-macro2" +version = "1.0.86" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f" + +[[package]] +name = "scoped-futures" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1473e24c637950c9bd38763220bea91ec3e095a89f672bbd7a10d03e77ba467" +dependencies = [ + "cfg-if", + "pin-utils", +] + +[[package]] +name = "scoped-tls" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294" + +[[package]] +name = "serde" +version = "1.0.204" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde-wasm-bindgen" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b" +dependencies = [ + "js-sys", + "serde", + "wasm-bindgen", +] + +[[package]] +name = "serde_derive" +version = "1.0.204" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "slab" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" +dependencies = [ + "autocfg", +] + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "syn" +version = "2.0.72" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc4b9b9bf2add8093d3f2c0204471e951b2285580335de42f9d2534f3ae7a8af" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tokio" +version = "1.39.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "daa4fb1bc778bd6f04cbfc4bb2d06a7396a8f299dc33ea1900cedaa316f467b1" +dependencies = [ + "backtrace", + "bytes", + "pin-project-lite", + "tokio-macros", +] + +[[package]] +name = "tokio-macros" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "wasm-bindgen" +version = "0.2.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8" +dependencies = [ + "cfg-if", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da" +dependencies = [ + "bumpalo", + "log", + "once_cell", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96" + +[[package]] +name = "wasm-bindgen-test" +version = "0.3.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9bf62a58e0780af3e852044583deee40983e5886da43a271dd772379987667b" +dependencies = [ + "console_error_panic_hook", + "js-sys", + "scoped-tls", + "wasm-bindgen", + "wasm-bindgen-futures", + "wasm-bindgen-test-macro", +] + +[[package]] +name = "wasm-bindgen-test-macro" +version = "0.3.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7f89739351a2e03cb94beb799d47fb2cac01759b40ec441f7de39b00cbf7ef0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "web-sys" +version = "0.3.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "zerocopy" +version = "0.7.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0" +dependencies = [ + "byteorder", + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.7.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/diesel-wasm-sqlite/Cargo.toml b/diesel-wasm-sqlite/Cargo.toml index ae566a745..555aee523 100644 --- a/diesel-wasm-sqlite/Cargo.toml +++ b/diesel-wasm-sqlite/Cargo.toml @@ -19,6 +19,8 @@ tokio = { version = "1.38", default-features = false, features = ["rt", "macros" futures = "0.3" async-trait = "0.1" bitflags = "2.6" +serde = { version = "1.0", features = ["derive"] } +serde-wasm-bindgen = "0.6" [dev-dependencies] rand = "0.8" @@ -33,3 +35,6 @@ crate-type = ["cdylib", "rlib"] [features] default = ["console_error_panic_hook"] +[build] +target = "wasm32-unknown-unknown" + diff --git a/diesel-wasm-sqlite/README.md b/diesel-wasm-sqlite/README.md index 608cdda29..77b146779 100644 --- a/diesel-wasm-sqlite/README.md +++ b/diesel-wasm-sqlite/README.md @@ -17,3 +17,9 @@ wasm-pack test --chrome --headless - [ ] wa-sqlite should be included in `pkg` build w/o manual copy (wasm-pack issue?) - [ ] OPFS + +# Notes + +- rust-analyzer doesn't like crates with different targets in the same + workspace. If you want this to work well with your LSP, open + `diesel-wasm-sqlite` as it's own project. diff --git a/diesel-wasm-sqlite/package-lock.json b/diesel-wasm-sqlite/package-lock.json new file mode 100644 index 000000000..e92a88e09 --- /dev/null +++ b/diesel-wasm-sqlite/package-lock.json @@ -0,0 +1,756 @@ +{ + "name": "diesel-wasm-sqlite", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "diesel-wasm-sqlite", + "version": "1.0.0", + "dependencies": { + "@xmtp/wa-sqlite": "^1.0.1" + }, + "devDependencies": { + "@rollup/plugin-node-resolve": "^15.2.3", + "rollup": "^4.19.0", + "rollup-plugin-base64": "^1.0.1", + "rollup-plugin-copy": "^3.5.0" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@rollup/plugin-node-resolve": { + "version": "15.2.3", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "@types/resolve": "1.20.2", + "deepmerge": "^4.2.2", + "is-builtin-module": "^3.2.1", + "is-module": "^1.0.0", + "resolve": "^1.22.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^2.78.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/pluginutils": { + "version": "5.1.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "estree-walker": "^2.0.2", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.19.0", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@types/estree": { + "version": "1.0.5", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/fs-extra": { + "version": "8.1.5", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/glob": { + "version": "7.2.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/minimatch": "*", + "@types/node": "*" + } + }, + "node_modules/@types/minimatch": { + "version": "5.1.2", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "20.14.11", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "node_modules/@types/resolve": { + "version": "1.20.2", + "dev": true, + "license": "MIT" + }, + "node_modules/@xmtp/wa-sqlite": { + "version": "1.0.1" + }, + "node_modules/array-union": { + "version": "2.1.0", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "dev": true, + "license": "MIT" + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "dev": true, + "license": "MIT", + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/builtin-modules": { + "version": "3.3.0", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/colorette": { + "version": "1.4.0", + "dev": true, + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "dev": true, + "license": "MIT" + }, + "node_modules/deepmerge": { + "version": "4.3.1", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/dir-glob": { + "version": "3.0.1", + "dev": true, + "license": "MIT", + "dependencies": { + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/estree-walker": { + "version": "2.0.2", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-glob": { + "version": "3.3.2", + "dev": true, + "license": "MIT", + "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" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fastq": { + "version": "1.17.1", + "dev": true, + "license": "ISC", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fill-range": { + "version": "7.1.1", + "dev": true, + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/fs-extra": { + "version": "8.1.0", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^4.0.0", + "universalify": "^0.1.0" + }, + "engines": { + "node": ">=6 <7 || >=8" + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "dev": true, + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/glob-parent": { + "version": "5.1.2", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/globby": { + "version": "10.0.1", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/glob": "^7.1.1", + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.0.3", + "glob": "^7.1.3", + "ignore": "^5.1.1", + "merge2": "^1.2.3", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/globby/node_modules/glob": { + "version": "7.2.3", + "dev": true, + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "dev": true, + "license": "ISC" + }, + "node_modules/hasown": { + "version": "2.0.2", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ignore": { + "version": "5.3.1", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "dev": true, + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "dev": true, + "license": "ISC" + }, + "node_modules/is-builtin-module": { + "version": "3.2.1", + "dev": true, + "license": "MIT", + "dependencies": { + "builtin-modules": "^3.3.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-core-module": { + "version": "2.15.0", + "dev": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-module": { + "version": "1.0.0", + "dev": true, + "license": "MIT" + }, + "node_modules/is-number": { + "version": "7.0.0", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-plain-object": { + "version": "3.0.1", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/jsonfile": { + "version": "4.0.0", + "dev": true, + "license": "MIT", + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/merge2": { + "version": "1.4.1", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.7", + "dev": true, + "license": "MIT", + "dependencies": { + "braces": "^3.0.3", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/minimatch": { + "version": "3.1.2", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/once": { + "version": "1.4.0", + "dev": true, + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "dev": true, + "license": "MIT" + }, + "node_modules/path-type": { + "version": "4.0.0", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/picomatch": { + "version": "2.3.1", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/resolve": { + "version": "1.22.8", + "dev": true, + "license": "MIT", + "dependencies": { + "is-core-module": "^2.13.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/reusify": { + "version": "1.0.4", + "dev": true, + "license": "MIT", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rollup": { + "version": "4.19.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.5" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.19.0", + "@rollup/rollup-android-arm64": "4.19.0", + "@rollup/rollup-darwin-arm64": "4.19.0", + "@rollup/rollup-darwin-x64": "4.19.0", + "@rollup/rollup-linux-arm-gnueabihf": "4.19.0", + "@rollup/rollup-linux-arm-musleabihf": "4.19.0", + "@rollup/rollup-linux-arm64-gnu": "4.19.0", + "@rollup/rollup-linux-arm64-musl": "4.19.0", + "@rollup/rollup-linux-powerpc64le-gnu": "4.19.0", + "@rollup/rollup-linux-riscv64-gnu": "4.19.0", + "@rollup/rollup-linux-s390x-gnu": "4.19.0", + "@rollup/rollup-linux-x64-gnu": "4.19.0", + "@rollup/rollup-linux-x64-musl": "4.19.0", + "@rollup/rollup-win32-arm64-msvc": "4.19.0", + "@rollup/rollup-win32-ia32-msvc": "4.19.0", + "@rollup/rollup-win32-x64-msvc": "4.19.0", + "fsevents": "~2.3.2" + } + }, + "node_modules/rollup-plugin-base64": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/rollup-plugin-base64/-/rollup-plugin-base64-1.0.1.tgz", + "integrity": "sha512-IbdX8fjuXO/Op3hYmRPjVo0VwcSenwsQDaDTFdoe+70B5ZGoLMtr96L2yhHXCfxv7HwZVvxZqLsuWj6VwzRt3g==", + "dev": true, + "dependencies": { + "@rollup/pluginutils": "^3.1.0" + } + }, + "node_modules/rollup-plugin-base64/node_modules/@rollup/pluginutils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-3.1.0.tgz", + "integrity": "sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==", + "dev": true, + "dependencies": { + "@types/estree": "0.0.39", + "estree-walker": "^1.0.1", + "picomatch": "^2.2.2" + }, + "engines": { + "node": ">= 8.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0" + } + }, + "node_modules/rollup-plugin-base64/node_modules/@types/estree": { + "version": "0.0.39", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz", + "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==", + "dev": true + }, + "node_modules/rollup-plugin-base64/node_modules/estree-walker": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-1.0.1.tgz", + "integrity": "sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==", + "dev": true + }, + "node_modules/rollup-plugin-base64/node_modules/rollup": { + "version": "2.79.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.1.tgz", + "integrity": "sha512-uKxbd0IhMZOhjAiD5oAFp7BqvkA4Dv47qpOCtaNvng4HBwdbWtdOh8f5nZNuk2rp51PMGk3bzfWu5oayNEuYnw==", + "dev": true, + "peer": true, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=10.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/rollup-plugin-copy": { + "version": "3.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/fs-extra": "^8.0.1", + "colorette": "^1.1.0", + "fs-extra": "^8.1.0", + "globby": "10.0.1", + "is-plain-object": "^3.0.0" + }, + "engines": { + "node": ">=8.3" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/slash": { + "version": "3.0.0", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "dev": true, + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/undici-types": { + "version": "5.26.5", + "dev": true, + "license": "MIT" + }, + "node_modules/universalify": { + "version": "0.1.2", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "dev": true, + "license": "ISC" + } + } +} diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index 225640279..a3a89aaba 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -63,6 +63,99 @@ export class SQLite { this.sqlite3.result_null(context); } + bind(stmt, i, value) { + try { + return this.sqlite3.bind(stmt, i, value); + } catch (error) { + console.log("bind err"); + throw error; + } + } + + bind_blob(stmt, i, value) { + try { + return this.sqlite3.bind_blob(stmt, i, value); + } catch (error) { + console.log("bind blob error"); + throw error; + } + } + + bind_collection(stmt, bindings) { + try { + return this.sqlite3.bind_collection(stmt, bindings); + } catch (error) { + console.log("bind collection error"); + throw error; + } + } + + bind_double(stmt, i, value) { + try { + return this.sqlite3.bind_double(stmt, i, value); + } catch (error) { + console.log("bind double error"); + throw error; + } + } + + bind_int(stmt, i, value) { + try { + return this.sqlite3.bind_int(stmt, i, value); + } catch (error) { + console.log("bind int error"); + throw error; + } + } + + bind_int64(stmt, i, value) { + try { + return this.sqlite3.bind_int64(stmt, i, value); + } catch (error) { + console.log("bind int644 error"); + throw error; + } + } + + bind_null(stmt, i) { + try { + return this.sqlite3.bind_null(stmt, i); + } catch (error) { + console.log("bind null error"); + throw error; + } + } + + bind_parameter_count(stmt) -> i32 { + return this.sqlite3.bind_parameter_count(stmt); + } + + bind_parameter_name(stmt, i) -> string { + return this.sqlite3.bind_paramater_name(stmt, it); + } + + bind_text(stmt, i, value) { + try { + this.sqlite3.bind_text(stmt, i, value); + } catch (error) { + console.log("bind text error"); + throw error; + } + } + + async reset(stmt) { + try { + return await this.sqlite3.reset(stmt); + } catch (error) { + console.log("reset err"); + throw error; + } + } + + value(pValue) { + this.sqlite3.value(pValue); + } + async open_v2(database_url, iflags) { try { console.log("Opening database!", database_url); @@ -84,10 +177,27 @@ export class SQLite { } } + finalize(stmt) { + try { + return this.sqlite3.finalize(stmt); + } catch (error) { + console.log("stmt error"); + } + } + changes(db) { return this.sqlite3.changes(db); } + async prepare(database, sql, options) { + try { + await this.sqlite3.statements(database, sql, options); + } catch (error) { + console.log("sqlite prepare error"); + throw error; + } + } + batch_execute(database, query) { try { sqlite3.exec(database, query); diff --git a/diesel-wasm-sqlite/src/backend.rs b/diesel-wasm-sqlite/src/backend.rs index 9e251eff6..d3e5465a7 100644 --- a/diesel-wasm-sqlite/src/backend.rs +++ b/diesel-wasm-sqlite/src/backend.rs @@ -38,9 +38,9 @@ pub enum SqliteType { impl Backend for WasmSqlite { type QueryBuilder = SqliteQueryBuilder; - type RawValue<'a> = (); - // type RawValue<'a> = SqliteValue<'a, 'a, 'a>; - type BindCollector<'a> = SqliteBindCollector<'a>; + // type RawValue<'a> = (); + type RawValue<'a> = SqliteValue<'a, 'a, 'a>; + type BindCollector<'a> = SqliteBindCollector; } impl TypeMetadata for WasmSqlite { diff --git a/diesel-wasm-sqlite/src/connection/bind_collector.rs b/diesel-wasm-sqlite/src/connection/bind_collector.rs index 3258aef9e..7f9322407 100644 --- a/diesel-wasm-sqlite/src/connection/bind_collector.rs +++ b/diesel-wasm-sqlite/src/connection/bind_collector.rs @@ -1,15 +1,20 @@ use crate::{SqliteType, WasmSqlite}; -use diesel::query_builder::{BindCollector, MoveableBindCollector}; -use diesel::result::QueryResult; -use diesel::serialize::{IsNull, Output}; -use diesel::sql_types::HasSqlType; +use diesel::{ + query_builder::{BindCollector, MoveableBindCollector}, + result::QueryResult, + serialize::{IsNull, Output}, + sql_types::HasSqlType, +}; +use wasm_bindgen::JsValue; + +pub type BindValue = JsValue; #[derive(Debug, Default)] -pub struct SqliteBindCollector<'a> { - pub(crate) binds: Vec<(InternalSqliteBindValue<'a>, SqliteType)>, +pub struct SqliteBindCollector { + pub(crate) binds: Vec<(JsValue, SqliteType)>, } -impl SqliteBindCollector<'_> { +impl SqliteBindCollector { pub(crate) fn new() -> Self { Self { binds: Vec::new() } } @@ -140,7 +145,7 @@ impl InternalSqliteBindValue<'_> { } } -impl<'a> BindCollector<'a, WasmSqlite> for SqliteBindCollector<'a> { +impl<'a> BindCollector<'a, WasmSqlite> for SqliteBindCollector { type Buffer = SqliteBindValue<'a>; fn push_bound_value(&mut self, bind: &'a U, metadata_lookup: &mut ()) -> QueryResult<()> @@ -157,6 +162,7 @@ impl<'a> BindCollector<'a, WasmSqlite> for SqliteBindCollector<'a> { .map_err(diesel::result::Error::SerializationError)?; let bind = to_sql_output.into_inner(); let metadata = WasmSqlite::metadata(metadata_lookup); + self.binds.push(( match is_null { IsNull::No => bind.inner, @@ -221,7 +227,7 @@ pub struct SqliteBindCollectorData { binds: Vec<(OwnedSqliteBindValue, SqliteType)>, } -impl MoveableBindCollector for SqliteBindCollector<'_> { +impl MoveableBindCollector for SqliteBindCollector { type BindData = SqliteBindCollectorData; fn moveable(&self) -> Self::BindData { diff --git a/diesel-wasm-sqlite/src/connection/mod.rs b/diesel-wasm-sqlite/src/connection/mod.rs index 8061d32c2..46097c0e8 100644 --- a/diesel-wasm-sqlite/src/connection/mod.rs +++ b/diesel-wasm-sqlite/src/connection/mod.rs @@ -1,12 +1,12 @@ mod bind_collector; // mod functions; -// mod owned_row; +mod owned_row; mod raw; -// mod row; +mod row; // mod serialized_database; -// mod sqlite_value; +mod sqlite_value; // mod statement_iterator; -// mod stmt; +mod stmt; pub(crate) use self::bind_collector::SqliteBindCollector; pub use self::bind_collector::SqliteBindValue; diff --git a/diesel-wasm-sqlite/src/connection/owned_row.rs b/diesel-wasm-sqlite/src/connection/owned_row.rs index 43e225d0e..f29dd8370 100644 --- a/diesel-wasm-sqlite/src/connection/owned_row.rs +++ b/diesel-wasm-sqlite/src/connection/owned_row.rs @@ -1,9 +1,11 @@ use std::sync::Arc; use super::sqlite_value::{OwnedSqliteValue, SqliteValue}; -use crate::backend::Backend; -use crate::row::{Field, PartialRow, Row, RowIndex, RowSealed}; -use crate::sqlite::Sqlite; +use crate::WasmSqlite; +use diesel::{ + backend::Backend, + row::{Field, PartialRow, Row, RowIndex, RowSealed}, +}; #[derive(Debug)] pub struct OwnedSqliteRow { @@ -25,7 +27,7 @@ impl OwnedSqliteRow { impl RowSealed for OwnedSqliteRow {} -impl<'a> Row<'a, Sqlite> for OwnedSqliteRow { +impl<'a> Row<'a, WasmSqlite> for OwnedSqliteRow { type Field<'field> = OwnedSqliteField<'field> where 'a: 'field, Self: 'field; type InnerPartialRow = Self; @@ -74,7 +76,7 @@ pub struct OwnedSqliteField<'row> { pub(super) col_idx: i32, } -impl<'row> Field<'row, Sqlite> for OwnedSqliteField<'row> { +impl<'row> Field<'row, WasmSqlite> for OwnedSqliteField<'row> { fn field_name(&self) -> Option<&str> { self.row .column_names @@ -86,7 +88,7 @@ impl<'row> Field<'row, Sqlite> for OwnedSqliteField<'row> { self.value().is_none() } - fn value(&self) -> Option<::RawValue<'row>> { + fn value(&self) -> Option<::RawValue<'row>> { SqliteValue::from_owned_row(self.row, self.col_idx) } } diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs index 0ea58dc13..8a1d2beb4 100644 --- a/diesel-wasm-sqlite/src/connection/raw.rs +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -1,10 +1,6 @@ #![allow(unsafe_code)] // ffi calls -// use std::ffi::{CString, NulError}; // use std::io::{stderr, Write}; -// use std::os::raw as libc; -// use std::ptr::NonNull; -// use std::{mem, ptr, slice, str}; // use super::functions::{build_sql_function_args, process_sql_function_result}; // use super::serialized_database::SerializedDatabase; @@ -105,101 +101,6 @@ impl RawConnection { Ok(()) } - /* - pub(super) fn register_aggregate_function( - &self, - fn_name: &str, - num_args: usize, - ) -> QueryResult<()> - where - A: SqliteAggregateFunction + 'static + Send + std::panic::UnwindSafe, - Args: FromSqlRow, - Ret: ToSql, - Sqlite: HasSqlType, - { - let fn_name = Self::get_fn_name(fn_name)?; - let flags = Self::get_flags(false); - - let result = unsafe { - ffi::sqlite3_create_function_v2( - self.internal_connection.as_ptr(), - fn_name.as_ptr(), - num_args as _, - flags, - ptr::null_mut(), - None, - Some(run_aggregator_step_function::<_, _, _, _, A>), - Some(run_aggregator_final_function::<_, _, _, _, A>), - None, - ) - }; - - Self::process_sql_function_result(result) - } - - pub(super) fn register_collation_function( - &self, - collation_name: &str, - collation: F, - ) -> QueryResult<()> - where - F: Fn(&str, &str) -> std::cmp::Ordering + std::panic::UnwindSafe + Send + 'static, - { - let callback_fn = Box::into_raw(Box::new(CollationUserPtr { - callback: collation, - collation_name: collation_name.to_owned(), - })); - let collation_name = Self::get_fn_name(collation_name)?; - - let result = unsafe { - ffi::sqlite3_create_collation_v2( - self.internal_connection.as_ptr(), - collation_name.as_ptr(), - ffi::SQLITE_UTF8, - callback_fn as *mut _, - Some(run_collation_function::), - Some(destroy_boxed::>), - ) - }; - - let result = Self::process_sql_function_result(result); - if result.is_err() { - destroy_boxed::>(callback_fn as *mut _); - } - result - } - - pub(super) fn serialize(&mut self) -> SerializedDatabase { - unsafe { - let mut size: ffi::sqlite3_int64 = 0; - let data_ptr = ffi::sqlite3_serialize( - self.internal_connection.as_ptr(), - std::ptr::null(), - &mut size as *mut _, - 0, - ); - SerializedDatabase::new(data_ptr, size as usize) - } - } - - pub(super) fn deserialize(&mut self, data: &[u8]) -> QueryResult<()> { - // the cast for `ffi::SQLITE_DESERIALIZE_READONLY` is required for old libsqlite3-sys versions - #[allow(clippy::unnecessary_cast)] - unsafe { - let result = ffi::sqlite3_deserialize( - self.internal_connection.as_ptr(), - std::ptr::null(), - data.as_ptr() as *mut u8, - data.len() as i64, - data.len() as i64, - ffi::SQLITE_DESERIALIZE_READONLY as u32, - ); - - ensure_sqlite_ok(result, self.internal_connection.as_ptr()) - } - } - */ - fn get_flags(deterministic: bool) -> i32 { let mut flags = SqliteFlags::SQLITE_UTF8; if deterministic { @@ -207,29 +108,16 @@ impl RawConnection { } flags.bits() as i32 } - - /* - fn process_sql_function_result(result: i32) -> Result<(), Error> { - if result == ffi::SQLITE_OK { - Ok(()) - } else { - let error_message = super::error_message(result); - Err(DatabaseError( - DatabaseErrorKind::Unknown, - Box::new(error_message.to_string()), - )) - } - } - */ } -/* + +/* TODO: AsyncDrop impl Drop for RawConnection { fn drop(&mut self) { use std::thread::panicking; let sqlite3 = crate::get_sqlite_unchecked(); - let close_result = sqlite3.close(self.internal_connection); + let close_result = sqlite3.close(self.internal_connection).unwrap(); if close_result != ffi::SQLITE_OK { let error_message = super::error_message(close_result); @@ -273,267 +161,6 @@ impl From for SqliteCallbackError { Self::DieselError(e) } } - -struct CustomFunctionUserPtr { - callback: F, - function_name: String, -} -*/ - -/* -// Need a custom option type here, because the std lib one does not have guarantees about the discriminate values -// See: https://github.com/rust-lang/rfcs/blob/master/text/2195-really-tagged-unions.md#opaque-tags -#[repr(u8)] -enum OptionalAggregator { - // Discriminant is 0 - None, - Some(A), -} - -#[allow(warnings)] -extern "C" fn run_aggregator_step_function( - ctx: *mut ffi::sqlite3_context, - num_args: libc::c_int, - value_ptr: *mut *mut ffi::sqlite3_value, -) where - A: SqliteAggregateFunction + 'static + Send + std::panic::UnwindSafe, - Args: FromSqlRow, - Ret: ToSql, - Sqlite: HasSqlType, -{ - let result = std::panic::catch_unwind(move || { - let args = unsafe { slice::from_raw_parts_mut(value_ptr, num_args as _) }; - run_aggregator_step::(ctx, args) - }) - .unwrap_or_else(|e| { - Err(SqliteCallbackError::Panic(format!( - "{}::step() panicked", - std::any::type_name::() - ))) - }); - - match result { - Ok(()) => {} - Err(e) => e.emit(ctx), - } -} - -fn run_aggregator_step( - ctx: *mut ffi::sqlite3_context, - args: &mut [*mut ffi::sqlite3_value], -) -> Result<(), SqliteCallbackError> -where - A: SqliteAggregateFunction, - Args: FromSqlRow, -{ - static NULL_AG_CTX_ERR: &str = "An unknown error occurred. sqlite3_aggregate_context returned a null pointer. This should never happen."; - static NULL_CTX_ERR: &str = - "We've written the aggregator to the aggregate context, but it could not be retrieved."; - - let aggregate_context = unsafe { - // This block of unsafe code makes the following assumptions: - // - // * sqlite3_aggregate_context allocates sizeof::> - // bytes of zeroed memory as documented here: - // https://www.sqlite.org/c3ref/aggregate_context.html - // A null pointer is returned for negative or zero sized types, - // which should be impossible in theory. We check that nevertheless - // - // * OptionalAggregator::None has a discriminant of 0 as specified by - // #[repr(u8)] + RFC 2195 - // - // * If all bytes are zero, the discriminant is also zero, so we can - // assume that we get OptionalAggregator::None in this case. This is - // not UB as we only access the discriminant here, so we do not try - // to read any other zeroed memory. After that we initialize our enum - // by writing a correct value at this location via ptr::write_unaligned - // - // * We use ptr::write_unaligned as we did not found any guarantees that - // the memory will have a correct alignment. - // (Note I(weiznich): would assume that it is aligned correctly, but we - // we cannot guarantee it, so better be safe than sorry) - ffi::sqlite3_aggregate_context(ctx, std::mem::size_of::>() as i32) - }; - let aggregate_context = NonNull::new(aggregate_context as *mut OptionalAggregator); - let aggregator = unsafe { - match aggregate_context.map(|a| &mut *a.as_ptr()) { - Some(&mut OptionalAggregator::Some(ref mut agg)) => agg, - Some(a_ptr @ &mut OptionalAggregator::None) => { - ptr::write_unaligned(a_ptr as *mut _, OptionalAggregator::Some(A::default())); - if let OptionalAggregator::Some(ref mut agg) = a_ptr { - agg - } else { - return Err(SqliteCallbackError::Abort(NULL_CTX_ERR)); - } - } - None => { - return Err(SqliteCallbackError::Abort(NULL_AG_CTX_ERR)); - } - } - }; - let args = build_sql_function_args::(args)?; - - aggregator.step(args); - Ok(()) -} - -extern "C" fn run_aggregator_final_function( - ctx: *mut ffi::sqlite3_context, -) where - A: SqliteAggregateFunction + 'static + Send, - Args: FromSqlRow, - Ret: ToSql, - Sqlite: HasSqlType, -{ - static NO_AGGREGATOR_FOUND: &str = "We've written to the aggregator in the xStep callback. If xStep was never called, then ffi::sqlite_aggregate_context() would have returned a NULL pointer."; - let aggregate_context = unsafe { - // Within the xFinal callback, it is customary to set nBytes to 0 so no pointless memory - // allocations occur, a null pointer is returned in this case - // See: https://www.sqlite.org/c3ref/aggregate_context.html - // - // For the reasoning about the safety of the OptionalAggregator handling - // see the comment in run_aggregator_step_function. - ffi::sqlite3_aggregate_context(ctx, 0) - }; - - let result = std::panic::catch_unwind(|| { - let mut aggregate_context = NonNull::new(aggregate_context as *mut OptionalAggregator); - - let aggregator = if let Some(a) = aggregate_context.as_mut() { - let a = unsafe { a.as_mut() }; - match std::mem::replace(a, OptionalAggregator::None) { - OptionalAggregator::None => { - return Err(SqliteCallbackError::Abort(NO_AGGREGATOR_FOUND)); - } - OptionalAggregator::Some(a) => Some(a), - } - } else { - None - }; - - let res = A::finalize(aggregator); - let value = process_sql_function_result(&res)?; - // We've checked already that ctx is not null - unsafe { - value.result_of(&mut *ctx); - } - Ok(()) - }) - .unwrap_or_else(|_e| { - Err(SqliteCallbackError::Panic(format!( - "{}::finalize() panicked", - std::any::type_name::() - ))) - }); - if let Err(e) = result { - e.emit(ctx); - } -} - -unsafe fn context_error_str(ctx: *mut ffi::sqlite3_context, error: &str) { - ffi::sqlite3_result_error(ctx, error.as_ptr() as *const _, error.len() as _); -} - -struct CollationUserPtr { - callback: F, - collation_name: String, -} - -#[allow(warnings)] -extern "C" fn run_collation_function( - user_ptr: *mut libc::c_void, - lhs_len: libc::c_int, - lhs_ptr: *const libc::c_void, - rhs_len: libc::c_int, - rhs_ptr: *const libc::c_void, -) -> libc::c_int -where - F: Fn(&str, &str) -> std::cmp::Ordering + Send + std::panic::UnwindSafe + 'static, -{ - let user_ptr = user_ptr as *const CollationUserPtr; - let user_ptr = std::panic::AssertUnwindSafe(unsafe { user_ptr.as_ref() }); - - let result = std::panic::catch_unwind(|| { - let user_ptr = user_ptr.ok_or_else(|| { - SqliteCallbackError::Abort( - "Got a null pointer as data pointer. This should never happen", - ) - })?; - for (ptr, len, side) in &[(rhs_ptr, rhs_len, "rhs"), (lhs_ptr, lhs_len, "lhs")] { - if *len < 0 { - assert_fail!( - "An unknown error occurred. {}_len is negative. This should never happen.", - side - ); - } - if ptr.is_null() { - assert_fail!( - "An unknown error occurred. {}_ptr is a null pointer. This should never happen.", - side - ); - } - } - - let (rhs, lhs) = unsafe { - // Depending on the eTextRep-parameter to sqlite3_create_collation_v2() the strings can - // have various encodings. register_collation_function() always selects SQLITE_UTF8, so the - // pointers point to valid UTF-8 strings (assuming correct behavior of libsqlite3). - ( - str::from_utf8(slice::from_raw_parts(rhs_ptr as *const u8, rhs_len as _)), - str::from_utf8(slice::from_raw_parts(lhs_ptr as *const u8, lhs_len as _)), - ) - }; - - let rhs = - rhs.map_err(|_| SqliteCallbackError::Abort("Got an invalid UTF-8 string for rhs"))?; - let lhs = - lhs.map_err(|_| SqliteCallbackError::Abort("Got an invalid UTF-8 string for lhs"))?; - - Ok((user_ptr.callback)(rhs, lhs)) - }) - .unwrap_or_else(|p| { - Err(SqliteCallbackError::Panic( - user_ptr - .map(|u| u.collation_name.clone()) - .unwrap_or_default(), - )) - }); - - match result { - Ok(std::cmp::Ordering::Less) => -1, - Ok(std::cmp::Ordering::Equal) => 0, - Ok(std::cmp::Ordering::Greater) => 1, - Err(SqliteCallbackError::Abort(a)) => { - eprintln!( - "Collation function {} failed with: {}", - user_ptr - .map(|c| &c.collation_name as &str) - .unwrap_or_default(), - a - ); - std::process::abort() - } - Err(SqliteCallbackError::DieselError(e)) => { - eprintln!( - "Collation function {} failed with: {}", - user_ptr - .map(|c| &c.collation_name as &str) - .unwrap_or_default(), - e - ); - std::process::abort() - } - Err(SqliteCallbackError::Panic(msg)) => { - eprintln!("Collation function {} panicked", msg); - std::process::abort() - } - } -} - -extern "C" fn destroy_boxed(data: *mut libc::c_void) { - let ptr = data as *mut F; - unsafe { std::mem::drop(Box::from_raw(ptr)) }; -} */ #[cfg(test)] diff --git a/diesel-wasm-sqlite/src/connection/row.rs b/diesel-wasm-sqlite/src/connection/row.rs index 75cc27369..3d9f1d94f 100644 --- a/diesel-wasm-sqlite/src/connection/row.rs +++ b/diesel-wasm-sqlite/src/connection/row.rs @@ -5,9 +5,11 @@ use std::sync::Arc; use super::owned_row::OwnedSqliteRow; use super::sqlite_value::{OwnedSqliteValue, SqliteValue}; use super::stmt::StatementUse; -use crate::backend::Backend; -use crate::row::{Field, IntoOwnedRow, PartialRow, Row, RowIndex, RowSealed}; -use crate::sqlite::Sqlite; +use crate::WasmSqlite; +use diesel::{ + backend::Backend, + row::{Field, IntoOwnedRow, PartialRow, Row, RowIndex, RowSealed}, +}; #[allow(missing_debug_implementations)] pub struct SqliteRow<'stmt, 'query> { @@ -23,7 +25,7 @@ pub(super) enum PrivateSqliteRow<'stmt, 'query> { }, } -impl<'stmt> IntoOwnedRow<'stmt, Sqlite> for SqliteRow<'stmt, '_> { +impl<'stmt> IntoOwnedRow<'stmt, WasmSqlite> for SqliteRow<'stmt, '_> { type OwnedRow = OwnedSqliteRow; type Cache = Option]>>; @@ -129,7 +131,7 @@ impl<'stmt, 'query> PrivateSqliteRow<'stmt, 'query> { impl<'stmt, 'query> RowSealed for SqliteRow<'stmt, 'query> {} -impl<'stmt, 'query> Row<'stmt, Sqlite> for SqliteRow<'stmt, 'query> { +impl<'stmt, 'query> Row<'stmt, WasmSqlite> for SqliteRow<'stmt, 'query> { type Field<'field> = SqliteField<'field, 'field> where 'stmt: 'field, Self: 'field; type InnerPartialRow = Self; @@ -181,7 +183,7 @@ pub struct SqliteField<'stmt, 'query> { pub(super) col_idx: i32, } -impl<'stmt, 'query> Field<'stmt, Sqlite> for SqliteField<'stmt, 'query> { +impl<'stmt, 'query> Field<'stmt, WasmSqlite> for SqliteField<'stmt, 'query> { fn field_name(&self) -> Option<&str> { match &*self.row { PrivateSqliteRow::Direct(stmt) => stmt.field_name(self.col_idx), @@ -195,7 +197,7 @@ impl<'stmt, 'query> Field<'stmt, Sqlite> for SqliteField<'stmt, 'query> { self.value().is_none() } - fn value(&self) -> Option<::RawValue<'_>> { + fn value(&self) -> Option<::RawValue<'_>> { SqliteValue::new(Ref::clone(&self.row), self.col_idx) } } @@ -298,23 +300,23 @@ mod tests { let second_values = (second_fields.0.value(), second_fields.1.value()); assert_eq!( - >::from_nullable_sql(first_values.0) + >::from_nullable_sql(first_values.0) .unwrap(), expected[0].0 ); assert_eq!( - >::from_nullable_sql(first_values.1) + >::from_nullable_sql(first_values.1) .unwrap(), expected[0].1 ); assert_eq!( - >::from_nullable_sql(second_values.0) + >::from_nullable_sql(second_values.0) .unwrap(), expected[1].0 ); assert_eq!( - >::from_nullable_sql(second_values.1) + >::from_nullable_sql(second_values.1) .unwrap(), expected[1].1 ); @@ -323,7 +325,7 @@ mod tests { let first_values = (first_fields.0.value(), first_fields.1.value()); assert_eq!( - >::from_nullable_sql(first_values.0) + >::from_nullable_sql(first_values.0) .unwrap(), expected[0].0 ); diff --git a/diesel-wasm-sqlite/src/connection/sqlite_value.rs b/diesel-wasm-sqlite/src/connection/sqlite_value.rs index 7210d104b..d59febf59 100644 --- a/diesel-wasm-sqlite/src/connection/sqlite_value.rs +++ b/diesel-wasm-sqlite/src/connection/sqlite_value.rs @@ -1,11 +1,10 @@ #![allow(unsafe_code)] // ffi calls -extern crate libsqlite3_sys as ffi; use std::cell::Ref; -use std::ptr::NonNull; use std::{slice, str}; -use crate::sqlite::SqliteType; +use crate::{backend::SqliteType, sqlite_types}; +use wasm_bindgen::JsValue; use super::owned_row::OwnedSqliteRow; use super::row::PrivateSqliteRow; @@ -24,22 +23,16 @@ pub struct SqliteValue<'row, 'stmt, 'query> { // to safe the match statements for each method // According to benchmarks this leads to a ~20-30% speedup // + // // This is sound as long as nobody calls `stmt.step()` // while holding this value. We ensure this by including // a reference to the row above. - value: NonNull, + value: JsValue, } -#[derive(Debug)] -#[repr(transparent)] +#[derive(Debug, Clone)] pub(super) struct OwnedSqliteValue { - pub(super) value: NonNull, -} - -impl Drop for OwnedSqliteValue { - fn drop(&mut self) { - unsafe { ffi::sqlite3_value_free(self.value.as_ptr()) } - } + pub(super) value: JsValue, } // Unsafe Send impl safe since sqlite3_value is built with sqlite3_value_dup @@ -148,25 +141,14 @@ impl<'row, 'stmt, 'query> SqliteValue<'row, 'stmt, 'query> { } impl OwnedSqliteValue { - pub(super) fn copy_from_ptr(ptr: NonNull) -> Option { - let tpe = unsafe { ffi::sqlite3_value_type(ptr.as_ptr()) }; - if ffi::SQLITE_NULL == tpe { + pub(super) fn new_from_ptr(ptr: &JsValue) -> Option { + let sqlite3 = crate::get_sqlite_unchecked(); + let value = sqlite3.value(ptr); + + if value.is_null() { return None; } - let value = unsafe { ffi::sqlite3_value_dup(ptr.as_ptr()) }; - Some(Self { - value: NonNull::new(value)?, - }) - } - pub(super) fn duplicate(&self) -> OwnedSqliteValue { - // self.value is a `NonNull` ptr so this cannot be null - let value = unsafe { ffi::sqlite3_value_dup(self.value.as_ptr()) }; - let value = NonNull::new(value).expect( - "Sqlite documentation states this returns only null if value is null \ - or OOM. If you ever see this panic message please open an issue at \ - https://github.com/diesel-rs/diesel.", - ); - OwnedSqliteValue { value } + Some(Self { value }) } } diff --git a/diesel-wasm-sqlite/src/connection/stmt.rs b/diesel-wasm-sqlite/src/connection/stmt.rs index 92b12465d..b8659ab86 100644 --- a/diesel-wasm-sqlite/src/connection/stmt.rs +++ b/diesel-wasm-sqlite/src/connection/stmt.rs @@ -1,53 +1,57 @@ -#![allow(unsafe_code)] // fii code +#![allow(unsafe_code)] //TODO: can probably remove for wa-sqlite use super::bind_collector::{InternalSqliteBindValue, SqliteBindCollector}; use super::raw::RawConnection; use super::sqlite_value::OwnedSqliteValue; -use crate::connection::statement_cache::{MaybeCached, PrepareForCache}; -use crate::connection::Instrumentation; -use crate::query_builder::{QueryFragment, QueryId}; -use crate::result::Error::DatabaseError; -use crate::result::*; -use crate::sqlite::{Sqlite, SqliteType}; -use libsqlite3_sys as ffi; +use crate::{ + sqlite_types::{PrepareOptions, SqlitePrepareFlags}, + SqliteType, WasmSqlite, +}; +use diesel::{ + connection::{ + statement_cache::{MaybeCached, PrepareForCache}, + Instrumentation, + }, + query_builder::{QueryFragment, QueryId}, + result::{Error::DatabaseError, *}, +}; use std::cell::OnceCell; -use std::ffi::{CStr, CString}; use std::io::{stderr, Write}; -use std::os::raw as libc; -use std::ptr::{self, NonNull}; + +use wasm_bindgen::JsValue; pub(super) struct Statement { - inner_statement: NonNull, + inner_statement: JsValue, } impl Statement { - pub(super) fn prepare( + pub(super) async fn prepare( raw_connection: &RawConnection, sql: &str, is_cached: PrepareForCache, ) -> QueryResult { - let mut stmt = ptr::null_mut(); - let mut unused_portion = ptr::null(); - // the cast for `ffi::SQLITE_PREPARE_PERSISTENT` is required for old libsqlite3-sys versions - #[allow(clippy::unnecessary_cast)] - let prepare_result = unsafe { - ffi::sqlite3_prepare_v3( - raw_connection.internal_connection.as_ptr(), - CString::new(sql)?.as_ptr(), - sql.len() as libc::c_int, - if matches!(is_cached, PrepareForCache::Yes) { - ffi::SQLITE_PREPARE_PERSISTENT as u32 - } else { - 0 - }, - &mut stmt, - &mut unused_portion, - ) + let sqlite3 = crate::get_sqlite_unchecked(); + let flags = if matches!(is_cached, PrepareForCache::Yes) { + Some(SqlitePrepareFlags::SQLITE_PREPARE_PERSISTENT.bits()) + } else { + None }; - ensure_sqlite_ok(prepare_result, raw_connection.internal_connection.as_ptr()).map(|_| { - Statement { - inner_statement: unsafe { NonNull::new_unchecked(stmt) }, - } + let options = PrepareOptions { + flags, + unscoped: None, + }; + + let stmt = sqlite3 + .prepare( + &raw_connection.internal_connection, + sql, + Some(serde_wasm_bindgen::to_value(&options).unwrap()), + ) + .await + .unwrap(); + + Ok(Statement { + inner_statement: stmt, }) } @@ -56,13 +60,16 @@ impl Statement { // `SqliteBindValue::String` or `SqliteBindValue::BorrowedString` is valid // till either a new value is bound to the same parameter or the underlying // prepared statement is dropped. - unsafe fn bind( - &mut self, - tpe: SqliteType, - value: InternalSqliteBindValue<'_>, - bind_index: i32, - ) -> QueryResult>> { - let mut ret_ptr = None; + fn bind(&self, _tpe: SqliteType, value: JsValue, bind_index: i32) -> QueryResult { + let sqlite3 = crate::get_sqlite_unchecked(); + let result = sqlite3 + .bind(&self.inner_statement, bind_index, value.into()) + .unwrap(); + + // TODO:insipx Pretty sure we can have a simpler implementation here + // making use of `wa-sqlite` `bind` which abstracts over the individual bind functions in + // sqlite3. However, not sure how this will work further up the stack. + /* let result = match (tpe, value) { (_, InternalSqliteBindValue::Null) => { ffi::sqlite3_bind_null(self.inner_statement.as_ptr(), bind_index) @@ -136,41 +143,24 @@ impl Statement { format!("Type mismatch: Expected {t:?}, got {b}").into(), )) } - }; - match ensure_sqlite_ok(result, self.raw_connection()) { - Ok(()) => Ok(ret_ptr), - Err(e) => { - if let Some(ptr) = ret_ptr { - // This is a `NonNul` ptr so it cannot be null - // It points to a slice internally as we did not apply - // any cast above. - std::mem::drop(Box::from_raw(ptr.as_ptr())) - } - Err(e) - } } + */ + Ok(result) } - fn reset(&mut self) { - unsafe { ffi::sqlite3_reset(self.inner_statement.as_ptr()) }; + async fn reset(&self) { + let sqlite3 = crate::get_sqlite_unchecked(); + let _ = sqlite3.reset(&self.inner_statement).await.unwrap(); } + /* not sure if there is equivalent method or just cloning the stmt is enough fn raw_connection(&self) -> *mut ffi::sqlite3 { unsafe { ffi::sqlite3_db_handle(self.inner_statement.as_ptr()) } } + */ } -pub(super) fn ensure_sqlite_ok( - code: libc::c_int, - raw_connection: *mut ffi::sqlite3, -) -> QueryResult<()> { - if code == ffi::SQLITE_OK { - Ok(()) - } else { - Err(last_error(raw_connection)) - } -} - +/* TODO: Useful for converting JS Error messages to Rust fn last_error(raw_connection: *mut ffi::sqlite3) -> Error { let error_message = last_error_message(raw_connection); let error_information = Box::new(error_message); @@ -191,27 +181,18 @@ fn last_error_message(conn: *mut ffi::sqlite3) -> String { c_str.to_string_lossy().into_owned() } + fn last_error_code(conn: *mut ffi::sqlite3) -> libc::c_int { unsafe { ffi::sqlite3_extended_errcode(conn) } } +*/ impl Drop for Statement { fn drop(&mut self) { - use std::thread::panicking; - - let raw_connection = self.raw_connection(); - let finalize_result = unsafe { ffi::sqlite3_finalize(self.inner_statement.as_ptr()) }; - if let Err(e) = ensure_sqlite_ok(finalize_result, raw_connection) { - if panicking() { - write!( - stderr(), - "Error finalizing SQLite prepared statement: {e:?}" - ) - .expect("Error writing to `stderr`"); - } else { - panic!("Error finalizing SQLite prepared statement: {:?}", e); - } - } + let sqlite3 = crate::get_sqlite_unchecked(); + let _ = sqlite3 + .finalize(&self.inner_statement) + .expect("Error finalized SQLite prepared statement"); } } @@ -231,7 +212,7 @@ struct BoundStatement<'stmt, 'query> { // We use a boxed queryfragment here just to erase the // generic type, we use NonNull to communicate // that this is a shared buffer - query: Option + 'query>>, + query: Option + 'query>>, // we need to store any owned bind values separately, as they are not // contained in the query itself. We use NonNull to // communicate that this is a shared buffer @@ -247,7 +228,7 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { instrumentation: &'stmt mut dyn Instrumentation, ) -> QueryResult> where - T: QueryFragment + QueryId + 'query, + T: QueryFragment + QueryId + 'query, { // Don't use a trait object here to prevent using a virtual function call // For sqlite this can introduce a measurable overhead @@ -256,7 +237,7 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { let query = Box::new(query); let mut bind_collector = SqliteBindCollector::new(); - query.collect_binds(&mut bind_collector, &mut (), &Sqlite)?; + query.collect_binds(&mut bind_collector, &mut (), &WasmSqlite)?; let SqliteBindCollector { binds } = bind_collector; let mut ret = BoundStatement { @@ -269,7 +250,7 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { ret.bind_buffers(binds)?; - let query = query as Box + 'query>; + let query = query as Box + 'query>; ret.query = NonNull::new(Box::into_raw(query)); Ok(ret) @@ -278,10 +259,7 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { // This is a separated function so that // not the whole constructor is generic over the query type T. // This hopefully prevents binary bloat. - fn bind_buffers( - &mut self, - binds: Vec<(InternalSqliteBindValue<'_>, SqliteType)>, - ) -> QueryResult<()> { + fn bind_buffers(&mut self, binds: Vec<(JsValue, SqliteType)>) -> QueryResult<()> { // It is useful to preallocate `binds_to_free` because it // - Guarantees that pushing inside it cannot panic, which guarantees the `Drop` // impl of `BoundStatement` will always re-`bind` as needed @@ -405,7 +383,7 @@ impl<'stmt, 'query> StatementUse<'stmt, 'query> { instrumentation: &'stmt mut dyn Instrumentation, ) -> QueryResult> where - T: QueryFragment + QueryId + 'query, + T: QueryFragment + QueryId + 'query, { Ok(Self { statement: BoundStatement::bind(statement, query, instrumentation)?, diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index 05765afad..e38d05461 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -23,6 +23,8 @@ unsafe impl Sync for SQLite {} #[wasm_bindgen(module = "/src/package.js")] extern "C" { pub type SQLite; + pub type SQLiteCompatibleType; + // pub type SqlitePrepareOptions; #[wasm_bindgen(constructor)] pub fn new(module: JsValue) -> SQLite; @@ -48,6 +50,60 @@ extern "C" { #[wasm_bindgen(method)] pub fn result_null(this: &SQLite, context: i32); + #[wasm_bindgen(method, catch)] + pub fn bind( + this: &SQLite, + stmt: &JsValue, + idx: i32, + value: SQLiteCompatibleType, + ) -> Result; + /* + #[wasm_bindgen(method, catch)] + pub fn bind_blob( + this: &SQLite, + stmt: &JsValue, + idx: i32, + value: Vec, + ) -> Result; + + // JsValue here is an interesting type that needs to be ported in order to make use of this + // but not currently using it. + + #[wasm_bindgen(method, catch)] + pub fn bind_collection( + this: &SQLite, + stmt: &JsValue, + bindings: JsValue, + ) -> Result; + + #[wasm_bindgen(method, catch)] + pub fn bind_double(this: &SQLite, stmt: &JsValue, idx: i32, value: f64) + -> Result; + + #[wasm_bindgen(method, catch)] + pub fn bind_int(this: &SQLite, stmt: &JsValue, idx: i32, value: i32) -> Result; + + #[wasm_bindgen(method, catch)] + pub fn bind_int64(this: &SQLite, stmt: &JsValue, idx: i32, value: i64) -> Result; + + #[wasm_bindgen(method, catch)] + pub fn bind_null(this: &SQLite, stmt: &JsValue, idx: i32) -> Result; + */ + #[wasm_bindgen(method)] + pub fn bind_parameter_count(this: &SQLite, stmt: &JsValue) -> i32; + + #[wasm_bindgen(method)] + pub fn bind_parameter_name(this: &SQLite, stmt: &JsValue, idx: i32) -> String; + + #[wasm_bindgen(method, catch)] + pub fn bind_text(this: &SQLite, stmt: &JsValue, idx: i32, value: &str) -> Result; + + #[wasm_bindgen(method, catch)] + pub async fn reset(this: &SQLite, stmt: &JsValue) -> Result; + + #[wasm_bindgen(method)] + pub fn value(this: &SQLite, pValue: &JsValue); + #[wasm_bindgen(method, catch)] pub async fn open_v2( this: &SQLite, @@ -58,9 +114,20 @@ extern "C" { #[wasm_bindgen(method, catch)] pub async fn exec(this: &SQLite, database: &JsValue, query: &str) -> Result<(), JsValue>; + #[wasm_bindgen(method, catch)] + pub fn finalize(this: &SQLite, stmt: &JsValue) -> Result<(), JsValue>; + #[wasm_bindgen(method)] pub fn changes(this: &SQLite, database: &JsValue) -> usize; + #[wasm_bindgen(method, catch)] + pub async fn prepare( + db: &SQLite, + database: &JsValue, + sql: &str, + options: Option, + ) -> Result; + #[wasm_bindgen(method, catch)] pub fn batch_execute(this: &SQLite, database: &JsValue, query: &str) -> Result<(), JsValue>; diff --git a/diesel-wasm-sqlite/src/lib.rs b/diesel-wasm-sqlite/src/lib.rs index d97cbb813..ffd6ad0f1 100644 --- a/diesel-wasm-sqlite/src/lib.rs +++ b/diesel-wasm-sqlite/src/lib.rs @@ -10,12 +10,8 @@ pub mod utils; compile_error!("This crate only suports the `wasm32-unknown-unknown` target"); use self::ffi::SQLite; -use diesel::{ - query_builder::{AsQuery, QueryFragment, QueryId}, - result::QueryResult, -}; use tokio::sync::OnceCell; -use wasm_bindgen::{prelude::wasm_bindgen, JsValue}; +use wasm_bindgen::JsValue; pub use backend::{SqliteType, WasmSqlite}; diff --git a/diesel-wasm-sqlite/src/package.js b/diesel-wasm-sqlite/src/package.js index 4a11058de..a1552fc96 100644 --- a/diesel-wasm-sqlite/src/package.js +++ b/diesel-wasm-sqlite/src/package.js @@ -2762,6 +2762,28 @@ class SQLite { this.sqlite3.result_null(context); } + bind(stmt, i, value) { + try { + return this.sqlite3.bind(stmt, i, value); + } catch (error) { + console.log("bind err"); + throw error; + } + } + + async reset(stmt) { + try { + return await this.sqlite3.reset(stmt); + } catch (error) { + console.log("reset err"); + throw error; + } + } + + value(pValue) { + this.sqlite3.value(pValue); + } + async open_v2(database_url, iflags) { try { console.log("Opening database!", database_url); @@ -2783,10 +2805,27 @@ class SQLite { } } + finalize(stmt) { + try { + return this.sqlite3.finalize(stmt); + } catch (error) { + console.log("stmt error"); + } + } + changes(db) { return this.sqlite3.changes(db); } + async prepare(database, sql, options) { + try { + await this.sqlite3.statements(database, sql, options); + } catch (error) { + console.log("sqlite prepare error"); + throw error; + } + } + batch_execute(database, query) { try { sqlite3.exec(database, query); diff --git a/diesel-wasm-sqlite/src/sqlite_types.rs b/diesel-wasm-sqlite/src/sqlite_types.rs index c9ede3420..20723a052 100644 --- a/diesel-wasm-sqlite/src/sqlite_types.rs +++ b/diesel-wasm-sqlite/src/sqlite_types.rs @@ -1,6 +1,14 @@ use super::backend::{SqliteType, WasmSqlite}; use bitflags::bitflags; use diesel::sql_types::*; +use serde::{Deserialize, Serialize}; + +/// `SqlitePrepareOptions` imported type +#[derive(Serialize, Deserialize, Default, Clone, Debug, Copy)] +pub struct PrepareOptions { + pub flags: Option, + pub unscoped: Option, +} macro_rules! impl_has_sql_type { ($type:ty, $sql_type:expr) => { @@ -52,7 +60,7 @@ bitflags! { } } -/// SQLite Text Encodings https://www.sqlite.org/capi3ref.html#SQLITE_ANY +// SQLite Text Encodings https://www.sqlite.org/capi3ref.html#SQLITE_ANY bitflags! { pub struct SqliteFlags: u32 { const SQLITE_UTF8 = 1; /* IMP: R-37514-35566 */ @@ -70,3 +78,12 @@ bitflags! { const SQLITE_RESULT_SUBTYPE = 0x001000000; } } + +// SQLite Prepare Flags https://www.sqlite.org/c3ref/c_prepare_normalize.html#sqlitepreparepersistent +bitflags! { + pub struct SqlitePrepareFlags: i32 { + const SQLITE_PREPARE_PERSISTENT = 0x01; + const SQLITE_PREPARE_NORMALIZE = 0x02; + const SQLITE_PREPARE_NO_VTAB = 0x04; + } +} From 8a2aafaeeb1f1391a25929dc792e4575960d9194 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Mon, 5 Aug 2024 17:48:22 -0400 Subject: [PATCH 15/28] restore xmtp_mls Cargo.toml --- xmtp_mls/Cargo.toml | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/xmtp_mls/Cargo.toml b/xmtp_mls/Cargo.toml index b25eddc58..63dc5b126 100644 --- a/xmtp_mls/Cargo.toml +++ b/xmtp_mls/Cargo.toml @@ -11,10 +11,9 @@ path = "src/bin/update-schema.rs" [features] default = ["native"] grpc = ["xmtp_proto/grpc"] -native = ["libsqlite3-sys/bundled-sqlcipher-vendored-openssl", "diesel_migrations/sqlite", "diesel/sqlite", "diesel/returning_clauses_for_sqlite_3_35", "tokio/rt-multi-thread", "tokio/macros"] +native = ["libsqlite3-sys/bundled-sqlcipher-vendored-openssl"] test-utils = ["xmtp_api_grpc"] bench = ["test-utils", "indicatif", "tracing-subscriber", "anyhow", "tracing-flame", "once_cell"] -web = ["openmls/js", "tokio/macros"] [dependencies] aes = "0.8.4" @@ -22,13 +21,19 @@ aes-gcm = { version = "0.10.3", features = ["std"] } async-trait.workspace = true bincode = "1.3.3" chrono = { workspace = true } -diesel = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend", features = ["r2d2"] } -diesel_migrations = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend" } +diesel = { version = "2.2.2", features = [ + "sqlite", + "r2d2", + "returning_clauses_for_sqlite_3_35", +] } +diesel_migrations = { version = "2.2.0", features = ["sqlite"] } ed25519-dalek = "2.1.1" ethers.workspace = true ethers-core.workspace = true futures.workspace = true +parking_lot = "0.12.3" hex.workspace = true +libsqlite3-sys = { version = "0.29.0", optional = true } log.workspace = true tracing.workspace = true openmls = { workspace = true, features = ["test-utils"] } @@ -45,7 +50,7 @@ sha2.workspace = true smart-default = "0.7.1" thiserror = { workspace = true } tls_codec = { workspace = true } -tokio = { workspace = true, default-features = false } +tokio = { workspace = true, features = ["rt-multi-thread"] } tokio-stream = { version = "0.1", features = ["sync"] } toml = "0.8.4" xmtp_cryptography = { workspace = true } @@ -53,9 +58,6 @@ xmtp_id = { path = "../xmtp_id" } xmtp_proto = { workspace = true, features = ["proto_full", "convert"] } xmtp_v2 = { path = "../xmtp_v2" } -# Native -libsqlite3-sys = { version = "0.28.0", optional = true } - # Test/Bench Utils xmtp_api_grpc = { path = "../xmtp_api_grpc", optional = true } tracing-subscriber = { workspace = true, optional = true } @@ -70,6 +72,8 @@ flume = "0.11" mockall = "0.11.4" mockito = "1.4.0" tempfile = "3.5.0" +tracing.workspace = true +tracing-subscriber.workspace = true tracing-log = "0.2.0" tracing-test = "0.2.4" xmtp_api_grpc = { path = "../xmtp_api_grpc" } From 613c84f0b0f197e5c8ae1f6b3c044a41c42804ad Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Mon, 5 Aug 2024 17:52:45 -0400 Subject: [PATCH 16/28] rename bundle --- diesel-wasm-sqlite/package.js | 30 ++++---- diesel-wasm-sqlite/rollup.config.js | 2 +- diesel-wasm-sqlite/src/ffi.rs | 2 +- ...{package.js => wa-sqlite-diesel-bundle.js} | 71 +++++++++++++++++++ 4 files changed, 88 insertions(+), 17 deletions(-) rename diesel-wasm-sqlite/src/{package.js => wa-sqlite-diesel-bundle.js} (99%) diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index a3a89aaba..bddfc0d0e 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -80,7 +80,7 @@ export class SQLite { throw error; } } - + bind_collection(stmt, bindings) { try { return this.sqlite3.bind_collection(stmt, bindings); @@ -88,8 +88,8 @@ export class SQLite { console.log("bind collection error"); throw error; } - } - + } + bind_double(stmt, i, value) { try { return this.sqlite3.bind_double(stmt, i, value); @@ -97,8 +97,8 @@ export class SQLite { console.log("bind double error"); throw error; } - } - + } + bind_int(stmt, i, value) { try { return this.sqlite3.bind_int(stmt, i, value); @@ -106,8 +106,8 @@ export class SQLite { console.log("bind int error"); throw error; } - } - + } + bind_int64(stmt, i, value) { try { return this.sqlite3.bind_int64(stmt, i, value); @@ -115,8 +115,8 @@ export class SQLite { console.log("bind int644 error"); throw error; } - } - + } + bind_null(stmt, i) { try { return this.sqlite3.bind_null(stmt, i); @@ -124,16 +124,16 @@ export class SQLite { console.log("bind null error"); throw error; } - } + } - bind_parameter_count(stmt) -> i32 { + bind_parameter_count(stmt) { return this.sqlite3.bind_parameter_count(stmt); - } + } - bind_parameter_name(stmt, i) -> string { + bind_parameter_name(stmt, i) { return this.sqlite3.bind_paramater_name(stmt, it); } - + bind_text(stmt, i, value) { try { this.sqlite3.bind_text(stmt, i, value); @@ -142,7 +142,7 @@ export class SQLite { throw error; } } - + async reset(stmt) { try { return await this.sqlite3.reset(stmt); diff --git a/diesel-wasm-sqlite/rollup.config.js b/diesel-wasm-sqlite/rollup.config.js index 5cb7854ff..881eeadf5 100644 --- a/diesel-wasm-sqlite/rollup.config.js +++ b/diesel-wasm-sqlite/rollup.config.js @@ -6,7 +6,7 @@ export default defineConfig([ { input: "package.js", output: { - file: "src/package.js", + file: "src/wa-sqlite-diesel-bundle.js", format: "es", }, plugins: [ diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index e38d05461..a4a841d84 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -20,7 +20,7 @@ unsafe impl Send for SQLite {} unsafe impl Sync for SQLite {} /// Direct Shim for wa-sqlite -#[wasm_bindgen(module = "/src/package.js")] +#[wasm_bindgen(module = "/src/wa-sqlite-diesel-bundle.js")] extern "C" { pub type SQLite; pub type SQLiteCompatibleType; diff --git a/diesel-wasm-sqlite/src/package.js b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js similarity index 99% rename from diesel-wasm-sqlite/src/package.js rename to diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js index a1552fc96..9d328779d 100644 --- a/diesel-wasm-sqlite/src/package.js +++ b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js @@ -2771,6 +2771,77 @@ class SQLite { } } + bind_blob(stmt, i, value) { + try { + return this.sqlite3.bind_blob(stmt, i, value); + } catch (error) { + console.log("bind blob error"); + throw error; + } + } + + bind_collection(stmt, bindings) { + try { + return this.sqlite3.bind_collection(stmt, bindings); + } catch (error) { + console.log("bind collection error"); + throw error; + } + } + + bind_double(stmt, i, value) { + try { + return this.sqlite3.bind_double(stmt, i, value); + } catch (error) { + console.log("bind double error"); + throw error; + } + } + + bind_int(stmt, i, value) { + try { + return this.sqlite3.bind_int(stmt, i, value); + } catch (error) { + console.log("bind int error"); + throw error; + } + } + + bind_int64(stmt, i, value) { + try { + return this.sqlite3.bind_int64(stmt, i, value); + } catch (error) { + console.log("bind int644 error"); + throw error; + } + } + + bind_null(stmt, i) { + try { + return this.sqlite3.bind_null(stmt, i); + } catch (error) { + console.log("bind null error"); + throw error; + } + } + + bind_parameter_count(stmt) { + return this.sqlite3.bind_parameter_count(stmt); + } + + bind_parameter_name(stmt, i) { + return this.sqlite3.bind_paramater_name(stmt, it); + } + + bind_text(stmt, i, value) { + try { + this.sqlite3.bind_text(stmt, i, value); + } catch (error) { + console.log("bind text error"); + throw error; + } + } + async reset(stmt) { try { return await this.sqlite3.reset(stmt); From 74638b24109d23df981d004dad54d54b741ab612 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Mon, 5 Aug 2024 19:32:05 -0400 Subject: [PATCH 17/28] finish stmt --- diesel-wasm-sqlite/package.js | 25 ++- .../src/connection/bind_collector.rs | 19 +- diesel-wasm-sqlite/src/connection/stmt.rs | 164 ++++++++---------- diesel-wasm-sqlite/src/ffi.rs | 14 +- diesel-wasm-sqlite/src/sqlite_types.rs | 5 + .../src/wa-sqlite-diesel-bundle.js | 25 ++- 6 files changed, 148 insertions(+), 104 deletions(-) diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index bddfc0d0e..96bffebd1 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -189,18 +189,39 @@ export class SQLite { return this.sqlite3.changes(db); } + clear_bindings(stmt) { + return this.sqlite3.clear_bindings(stmt); + } + async prepare(database, sql, options) { try { - await this.sqlite3.statements(database, sql, options); + return await this.sqlite3.statements(database, sql, options); } catch (error) { console.log("sqlite prepare error"); throw error; } } + async step(stmt) { + try { + return await this.sqlite3.step(stmt); + } catch (error) { + console.log("sqlite step error"); + throw error; + } + } + + column_name(stmt, idx) { + return this.sqlite3.column_name(stmt, idx); + } + + column_count(stmt) { + return this.sqlite3.column_count(stmt); + } + batch_execute(database, query) { try { - sqlite3.exec(database, query); + return sqlite3.exec(database, query); console.log("Batch exec'ed"); } catch { console.log("exec err"); diff --git a/diesel-wasm-sqlite/src/connection/bind_collector.rs b/diesel-wasm-sqlite/src/connection/bind_collector.rs index 7f9322407..6eef85140 100644 --- a/diesel-wasm-sqlite/src/connection/bind_collector.rs +++ b/diesel-wasm-sqlite/src/connection/bind_collector.rs @@ -5,16 +5,19 @@ use diesel::{ serialize::{IsNull, Output}, sql_types::HasSqlType, }; +use serde::{Deserialize, Serialize}; use wasm_bindgen::JsValue; +// TODO:insipx this file remains largely unchanged other than the ffi::. Candidate for shared code? + pub type BindValue = JsValue; #[derive(Debug, Default)] -pub struct SqliteBindCollector { - pub(crate) binds: Vec<(JsValue, SqliteType)>, +pub struct SqliteBindCollector<'a> { + pub(crate) binds: Vec<(InternalSqliteBindValue<'a>, SqliteType)>, } -impl SqliteBindCollector { +impl SqliteBindCollector<'_> { pub(crate) fn new() -> Self { Self { binds: Vec::new() } } @@ -99,7 +102,8 @@ impl<'a> From<&'a [u8]> for SqliteBindValue<'a> { } } -#[derive(Debug)] +#[derive(Debug, Serialize, Deserialize)] +#[serde(untagged)] pub(crate) enum InternalSqliteBindValue<'a> { BorrowedString(&'a str), String(Box), @@ -145,7 +149,7 @@ impl InternalSqliteBindValue<'_> { } } -impl<'a> BindCollector<'a, WasmSqlite> for SqliteBindCollector { +impl<'a> BindCollector<'a, WasmSqlite> for SqliteBindCollector<'a> { type Buffer = SqliteBindValue<'a>; fn push_bound_value(&mut self, bind: &'a U, metadata_lookup: &mut ()) -> QueryResult<()> @@ -179,7 +183,8 @@ impl<'a> BindCollector<'a, WasmSqlite> for SqliteBindCollector { } } -#[derive(Debug)] +#[derive(Debug, Serialize, Deserialize)] +#[serde(untagged)] enum OwnedSqliteBindValue { String(Box), Binary(Box<[u8]>), @@ -227,7 +232,7 @@ pub struct SqliteBindCollectorData { binds: Vec<(OwnedSqliteBindValue, SqliteType)>, } -impl MoveableBindCollector for SqliteBindCollector { +impl MoveableBindCollector for SqliteBindCollector<'_> { type BindData = SqliteBindCollectorData; fn moveable(&self) -> Self::BindData { diff --git a/diesel-wasm-sqlite/src/connection/stmt.rs b/diesel-wasm-sqlite/src/connection/stmt.rs index b8659ab86..a3a5b74d5 100644 --- a/diesel-wasm-sqlite/src/connection/stmt.rs +++ b/diesel-wasm-sqlite/src/connection/stmt.rs @@ -3,7 +3,7 @@ use super::bind_collector::{InternalSqliteBindValue, SqliteBindCollector}; use super::raw::RawConnection; use super::sqlite_value::OwnedSqliteValue; use crate::{ - sqlite_types::{PrepareOptions, SqlitePrepareFlags}, + sqlite_types::{result_codes, PrepareOptions, SqlitePrepareFlags}, SqliteType, WasmSqlite, }; use diesel::{ @@ -60,8 +60,15 @@ impl Statement { // `SqliteBindValue::String` or `SqliteBindValue::BorrowedString` is valid // till either a new value is bound to the same parameter or the underlying // prepared statement is dropped. - fn bind(&self, _tpe: SqliteType, value: JsValue, bind_index: i32) -> QueryResult { + fn bind( + &self, + _tpe: SqliteType, + value: InternalSqliteBindValue<'_>, + bind_index: i32, + ) -> QueryResult { let sqlite3 = crate::get_sqlite_unchecked(); + let value = + serde_wasm_bindgen::to_value(&value).expect("Bind value failed to convert to JsValue"); let result = sqlite3 .bind(&self.inner_statement, bind_index, value.into()) .unwrap(); @@ -69,6 +76,9 @@ impl Statement { // TODO:insipx Pretty sure we can have a simpler implementation here // making use of `wa-sqlite` `bind` which abstracts over the individual bind functions in // sqlite3. However, not sure how this will work further up the stack. + // This might not work because of differences in how serde_json recognizes js types + // and how wa-sqlite recogizes js types. In that case, need to resort to matching on + // individual types as below. /* let result = match (tpe, value) { (_, InternalSqliteBindValue::Null) => { @@ -153,6 +163,11 @@ impl Statement { let _ = sqlite3.reset(&self.inner_statement).await.unwrap(); } + fn clear_bindings(&self) { + let sqlite3 = crate::get_sqlite_unchecked(); + let _ = sqlite3.clear_bindings(&self.inner_statement).unwrap(); + } + /* not sure if there is equivalent method or just cloning the stmt is enough fn raw_connection(&self) -> *mut ffi::sqlite3 { unsafe { ffi::sqlite3_db_handle(self.inner_statement.as_ptr()) } @@ -190,6 +205,12 @@ fn last_error_code(conn: *mut ffi::sqlite3) -> libc::c_int { impl Drop for Statement { fn drop(&mut self) { let sqlite3 = crate::get_sqlite_unchecked(); + // TODO:insipx potential problems here. + // wa-sqlite does not throw an error if finalize fails: -- it might just crash + // doc: https://rhashimoto.github.io/wa-sqlite/docs/interfaces/SQLiteAPI.html#finalize.finalize-1 + // in that case we might not know if this errored or not + // maybe depends how wasm panic/errors work + // Worth unit testing the Drop implementation. let _ = sqlite3 .finalize(&self.inner_statement) .expect("Error finalized SQLite prepared statement"); @@ -216,7 +237,7 @@ struct BoundStatement<'stmt, 'query> { // we need to store any owned bind values separately, as they are not // contained in the query itself. We use NonNull to // communicate that this is a shared buffer - binds_to_free: Vec<(i32, Option>)>, + binds_to_free: Vec<(i32, Option)>, instrumentation: &'stmt mut dyn Instrumentation, has_error: bool, } @@ -251,7 +272,7 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { ret.bind_buffers(binds)?; let query = query as Box + 'query>; - ret.query = NonNull::new(Box::into_raw(query)); + ret.query = Some(query); Ok(ret) } @@ -259,7 +280,10 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { // This is a separated function so that // not the whole constructor is generic over the query type T. // This hopefully prevents binary bloat. - fn bind_buffers(&mut self, binds: Vec<(JsValue, SqliteType)>) -> QueryResult<()> { + fn bind_buffers( + &mut self, + binds: Vec<(InternalSqliteBindValue<'_>, SqliteType)>, + ) -> QueryResult<()> { // It is useful to preallocate `binds_to_free` because it // - Guarantees that pushing inside it cannot panic, which guarantees the `Drop` // impl of `BoundStatement` will always re-`bind` as needed @@ -289,81 +313,51 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { // * The type and value matches // * We ensure that corresponding buffers lives long enough below // * The statement is not used yet by `step` or anything else - let res = unsafe { self.statement.bind(tpe, bind, bind_idx) }?; + let bind_ptr = self.statement.bind(tpe, bind, bind_idx)?; // it's important to push these only after // the call to bind succeeded, otherwise we might attempt to // call bind to an non-existing bind position in // the destructor - if let Some(ptr) = res { - // Store the id + pointer for a owned bind - // as we must unbind and free them on drop - self.binds_to_free.push((bind_idx, Some(ptr))); - } else if is_borrowed_bind { + + if is_borrowed_bind { // Store the id's of borrowed binds to unbind them on drop self.binds_to_free.push((bind_idx, None)); + } else { + // Store the id + pointer for a owned bind + // as we must unbind and free them on drop + self.binds_to_free.push((bind_idx, Some(bind_ptr))); } } Ok(()) } - fn finish_query_with_error(mut self, e: &Error) { + fn finish_query_with_error(mut self, _e: &Error) { self.has_error = true; + /* if let Some(q) = self.query { // it's safe to get a reference from this ptr as it's guaranteed to not be null let q = unsafe { q.as_ref() }; self.instrumentation.on_connection_event( - crate::connection::InstrumentationEvent::FinishQuery { + diesel::connection::InstrumentationEvent::FinishQuery { query: &crate::debug_query(&q), error: Some(e), }, ); } + */ } } +// TODO: AsyncDrop impl<'stmt, 'query> Drop for BoundStatement<'stmt, 'query> { fn drop(&mut self) { // First reset the statement, otherwise the bind calls - // below will fails + // below will fail self.statement.reset(); + self.statement.clear_bindings(); - for (idx, buffer) in std::mem::take(&mut self.binds_to_free) { - unsafe { - // It's always safe to bind null values, as there is no buffer that needs to outlife something - self.statement - .bind(SqliteType::Text, InternalSqliteBindValue::Null, idx) - .expect( - "Binding a null value should never fail. \ - If you ever see this error message please open \ - an issue at diesels issue tracker containing \ - code how to trigger this message.", - ); - } - - if let Some(buffer) = buffer { - unsafe { - // Constructing the `Box` here is safe as we - // got the pointer from a box + it is guaranteed to be not null. - std::mem::drop(Box::from_raw(buffer.as_ptr())); - } - } - } - - if let Some(query) = self.query { - let query = unsafe { - // Constructing the `Box` here is safe as we - // got the pointer from a box + it is guaranteed to be not null. - Box::from_raw(query.as_ptr()) - }; - if !self.has_error { - self.instrumentation.on_connection_event( - crate::connection::InstrumentationEvent::FinishQuery { - query: &crate::debug_query(&query), - error: None, - }, - ); - } + if let Some(query) = &mut self.query { std::mem::drop(query); self.query = None; } @@ -373,7 +367,7 @@ impl<'stmt, 'query> Drop for BoundStatement<'stmt, 'query> { #[allow(missing_debug_implementations)] pub struct StatementUse<'stmt, 'query> { statement: BoundStatement<'stmt, 'query>, - column_names: OnceCell>, + column_names: OnceCell>, } impl<'stmt, 'query> StatementUse<'stmt, 'query> { @@ -391,13 +385,12 @@ impl<'stmt, 'query> StatementUse<'stmt, 'query> { }) } - pub(super) fn run(mut self) -> QueryResult<()> { - let r = unsafe { - // This is safe as we pass `first_step = true` - // and we consume the statement so nobody could - // access the columns later on anyway. - self.step(true).map(|_| ()) - }; + pub(super) async fn run(mut self) -> QueryResult<()> { + // This is safe as we pass `first_step = true` + // and we consume the statement so nobody could + // access the columns later on anyway. + let r = self.step(true).await.map(|_| ()); + if let Err(ref e) = r { self.statement.finish_query_with_error(e); } @@ -410,12 +403,18 @@ impl<'stmt, 'query> StatementUse<'stmt, 'query> { // // It's always safe to call this function with `first_step = true` as this removes // the cached column names - pub(super) unsafe fn step(&mut self, first_step: bool) -> QueryResult { - let res = match ffi::sqlite3_step(self.statement.statement.inner_statement.as_ptr()) { - ffi::SQLITE_DONE => Ok(false), - ffi::SQLITE_ROW => Ok(true), - _ => Err(last_error(self.statement.statement.raw_connection())), + pub(super) async fn step(&mut self, first_step: bool) -> QueryResult { + let sqlite3 = crate::get_sqlite_unchecked(); + let res = match sqlite3 + .step(&self.statement.statement.inner_statement) + .await + .unwrap() + { + result_codes::SQLITE_DONE => Ok(false), + result_codes::SQLITE_ROW => Ok(true), + _ => panic!("SQLite Step returned Unhandled Result Code. Turn into err message"), }; + if first_step { self.column_names = OnceCell::new(); } @@ -433,27 +432,15 @@ impl<'stmt, 'query> StatementUse<'stmt, 'query> { // Note: This function is marked as unsafe, as calling it can invalidate // other existing column name pointers on the same column. To prevent that, // it should maximally be called once per column at all. - unsafe fn column_name(&self, idx: i32) -> *const str { - let name = { - let column_name = - ffi::sqlite3_column_name(self.statement.statement.inner_statement.as_ptr(), idx); - assert!( - !column_name.is_null(), - "The Sqlite documentation states that it only returns a \ - null pointer here if we are in a OOM condition." - ); - CStr::from_ptr(column_name) - }; - name.to_str().expect( - "The Sqlite documentation states that this is UTF8. \ - If you see this error message something has gone \ - horribly wrong. Please open an issue at the \ - diesel repository.", - ) as *const str + fn column_name(&self, idx: i32) -> String { + let sqlite3 = crate::get_sqlite_unchecked(); + + sqlite3.column_name(&self.statement.statement.inner_statement, idx) } pub(super) fn column_count(&self) -> i32 { - unsafe { ffi::sqlite3_column_count(self.statement.statement.inner_statement.as_ptr()) } + let sqlite3 = crate::get_sqlite_unchecked(); + sqlite3.column_count(&self.statement.statement.inner_statement) } pub(super) fn index_for_column_name(&mut self, field_name: &str) -> Option { @@ -465,20 +452,12 @@ impl<'stmt, 'query> StatementUse<'stmt, 'query> { pub(super) fn field_name(&self, idx: i32) -> Option<&str> { let column_names = self.column_names.get_or_init(|| { let count = self.column_count(); - (0..count) - .map(|idx| unsafe { - // By initializing the whole vec at once we ensure that - // we really call this only once. - self.column_name(idx) - }) - .collect() + (0..count).map(|idx| self.column_name(idx)).collect() }); - column_names - .get(idx as usize) - .and_then(|c| unsafe { c.as_ref() }) + column_names.get(idx as usize).map(AsRef::as_ref) } - + /* pub(super) fn copy_value(&self, idx: i32) -> Option { OwnedSqliteValue::copy_from_ptr(self.column_value(idx)?) } @@ -489,6 +468,7 @@ impl<'stmt, 'query> StatementUse<'stmt, 'query> { }; NonNull::new(ptr) } + */ } #[cfg(test)] diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index a4a841d84..1cee7ce27 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -120,14 +120,26 @@ extern "C" { #[wasm_bindgen(method)] pub fn changes(this: &SQLite, database: &JsValue) -> usize; + #[wasm_bindgen(method, catch)] + pub async fn step(this: &SQLite, stmt: &JsValue) -> Result; + + #[wasm_bindgen(method, catch)] + pub fn clear_bindings(this: &SQLite, stmt: &JsValue) -> Result; + #[wasm_bindgen(method, catch)] pub async fn prepare( - db: &SQLite, + this: &SQLite, database: &JsValue, sql: &str, options: Option, ) -> Result; + #[wasm_bindgen(method)] + pub fn column_name(this: &SQLite, stmt: &JsValue, idx: i32) -> String; + + #[wasm_bindgen(method)] + pub fn column_count(this: &SQLite, stmt: &JsValue) -> i32; + #[wasm_bindgen(method, catch)] pub fn batch_execute(this: &SQLite, database: &JsValue, query: &str) -> Result<(), JsValue>; diff --git a/diesel-wasm-sqlite/src/sqlite_types.rs b/diesel-wasm-sqlite/src/sqlite_types.rs index 20723a052..a8304483d 100644 --- a/diesel-wasm-sqlite/src/sqlite_types.rs +++ b/diesel-wasm-sqlite/src/sqlite_types.rs @@ -3,6 +3,11 @@ use bitflags::bitflags; use diesel::sql_types::*; use serde::{Deserialize, Serialize}; +pub mod result_codes { + pub const SQLITE_DONE: i32 = 101; + pub const SQLITE_ROW: i32 = 100; +} + /// `SqlitePrepareOptions` imported type #[derive(Serialize, Deserialize, Default, Clone, Debug, Copy)] pub struct PrepareOptions { diff --git a/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js index 9d328779d..8c94e8a90 100644 --- a/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js +++ b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js @@ -2888,18 +2888,39 @@ class SQLite { return this.sqlite3.changes(db); } + clear_bindings(stmt) { + return this.sqlite3.clear_bindings(stmt); + } + async prepare(database, sql, options) { try { - await this.sqlite3.statements(database, sql, options); + return await this.sqlite3.statements(database, sql, options); } catch (error) { console.log("sqlite prepare error"); throw error; } } + async step(stmt) { + try { + return await this.sqlite3.step(stmt); + } catch (error) { + console.log("sqlite step error"); + throw error; + } + } + + column_name(stmt, idx) { + return this.sqlite3.column_name(stmt, idx); + } + + column_count(stmt) { + return this.sqlite3.column_count(stmt); + } + batch_execute(database, query) { try { - sqlite3.exec(database, query); + return sqlite3.exec(database, query); console.log("Batch exec'ed"); } catch { console.log("exec err"); From f7844158fca625a794913b4a61985fe633461926 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Mon, 5 Aug 2024 19:39:05 -0400 Subject: [PATCH 18/28] remove binds_to_free as it is unused --- diesel-wasm-sqlite/src/connection/stmt.rs | 55 +++++------------------ 1 file changed, 10 insertions(+), 45 deletions(-) diff --git a/diesel-wasm-sqlite/src/connection/stmt.rs b/diesel-wasm-sqlite/src/connection/stmt.rs index a3a5b74d5..68b03c871 100644 --- a/diesel-wasm-sqlite/src/connection/stmt.rs +++ b/diesel-wasm-sqlite/src/connection/stmt.rs @@ -15,7 +15,6 @@ use diesel::{ result::{Error::DatabaseError, *}, }; use std::cell::OnceCell; -use std::io::{stderr, Write}; use wasm_bindgen::JsValue; @@ -234,10 +233,6 @@ struct BoundStatement<'stmt, 'query> { // generic type, we use NonNull to communicate // that this is a shared buffer query: Option + 'query>>, - // we need to store any owned bind values separately, as they are not - // contained in the query itself. We use NonNull to - // communicate that this is a shared buffer - binds_to_free: Vec<(i32, Option)>, instrumentation: &'stmt mut dyn Instrumentation, has_error: bool, } @@ -264,7 +259,6 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { let mut ret = BoundStatement { statement, query: None, - binds_to_free: Vec::new(), instrumentation, has_error: false, }; @@ -284,50 +278,21 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { &mut self, binds: Vec<(InternalSqliteBindValue<'_>, SqliteType)>, ) -> QueryResult<()> { - // It is useful to preallocate `binds_to_free` because it - // - Guarantees that pushing inside it cannot panic, which guarantees the `Drop` - // impl of `BoundStatement` will always re-`bind` as needed - // - Avoids reallocations - self.binds_to_free.reserve( - binds - .iter() - .filter(|&(b, _)| { - matches!( - b, - InternalSqliteBindValue::BorrowedBinary(_) - | InternalSqliteBindValue::BorrowedString(_) - | InternalSqliteBindValue::String(_) - | InternalSqliteBindValue::Binary(_) - ) - }) - .count(), - ); for (bind_idx, (bind, tpe)) in (1..).zip(binds) { - let is_borrowed_bind = matches!( - bind, - InternalSqliteBindValue::BorrowedString(_) - | InternalSqliteBindValue::BorrowedBinary(_) - ); - // It's safe to call bind here as: // * The type and value matches // * We ensure that corresponding buffers lives long enough below // * The statement is not used yet by `step` or anything else - let bind_ptr = self.statement.bind(tpe, bind, bind_idx)?; - - // it's important to push these only after - // the call to bind succeeded, otherwise we might attempt to - // call bind to an non-existing bind position in - // the destructor - - if is_borrowed_bind { - // Store the id's of borrowed binds to unbind them on drop - self.binds_to_free.push((bind_idx, None)); - } else { - // Store the id + pointer for a owned bind - // as we must unbind and free them on drop - self.binds_to_free.push((bind_idx, Some(bind_ptr))); - } + let _ = self.statement.bind(tpe, bind, bind_idx)?; + + // we don't track binds to free like sqlite3 C bindings + // The assumption is that wa-sqlite, being WASM run in web browser that + // lies in the middle of rust -> sqlite, takes care of this for us. + // if we run into memory issues, especailly memory leaks + // this should be the first place to pay attention to. + // + // The bindings shuold be collected/freed with JS once `clear_bindings` is + // run on `Drop` for `BoundStatement` } Ok(()) } From e18369bb44cb9f364dcea4e8b35c7c23a503b302 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Tue, 6 Aug 2024 15:38:58 -0400 Subject: [PATCH 19/28] compiles --- diesel-wasm-sqlite/package.js | 45 +++++++ diesel-wasm-sqlite/src/backend.rs | 4 +- diesel-wasm-sqlite/src/connection/mod.rs | 4 +- diesel-wasm-sqlite/src/connection/raw.rs | 2 +- diesel-wasm-sqlite/src/connection/row.rs | 4 +- .../src/connection/sqlite_value.rs | 96 ++++++++------- diesel-wasm-sqlite/src/connection/stmt.rs | 112 +++--------------- diesel-wasm-sqlite/src/ffi.rs | 59 ++++++++- diesel-wasm-sqlite/src/sqlite_types.rs | 19 ++- .../src/wa-sqlite-diesel-bundle.js | 45 +++++++ 10 files changed, 240 insertions(+), 150 deletions(-) diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index 96bffebd1..ca65d63e9 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -156,6 +156,38 @@ export class SQLite { this.sqlite3.value(pValue); } + value_dup(pValue) { + return this.module._sqlite3_value_dup(pValue); + } + + value_blob(pValue) { + this.sqlite3.value_blob(pValue); + } + + value_bytes(pValue) { + this.sqlite3.value_bytes(pValue); + } + + value_double(pValue) { + this.sqlite3.value_double(pValue); + } + + value_int(pValue) { + this.sqlite3.value_int(pValue); + } + + value_int64(pValue) { + this.sqlite3.value_int64(pValue); + } + + value_text(pValue) { + this.sqlite3.value_text(pValue); + } + + value_type(pValue) { + this.sqlite3.value_type(pValue); + } + async open_v2(database_url, iflags) { try { console.log("Opening database!", database_url); @@ -193,6 +225,19 @@ export class SQLite { return this.sqlite3.clear_bindings(stmt); } + async close(db) { + try { + return this.sqlite3.close(db); + } catch (error) { + console.log("sqlite3.close error"); + throw error; + } + } + + column(stmt, i) { + return this.sqlite3.column(stmt, i); + } + async prepare(database, sql, options) { try { return await this.sqlite3.statements(database, sql, options); diff --git a/diesel-wasm-sqlite/src/backend.rs b/diesel-wasm-sqlite/src/backend.rs index d3e5465a7..4891c37e0 100644 --- a/diesel-wasm-sqlite/src/backend.rs +++ b/diesel-wasm-sqlite/src/backend.rs @@ -1,6 +1,7 @@ //! The SQLite backend use super::connection::SqliteBindCollector; +use super::connection::SqliteValue; use super::query_builder::SqliteQueryBuilder; use diesel::backend::*; use diesel::sql_types::TypeMetadata; @@ -38,9 +39,8 @@ pub enum SqliteType { impl Backend for WasmSqlite { type QueryBuilder = SqliteQueryBuilder; - // type RawValue<'a> = (); type RawValue<'a> = SqliteValue<'a, 'a, 'a>; - type BindCollector<'a> = SqliteBindCollector; + type BindCollector<'a> = SqliteBindCollector<'a>; } impl TypeMetadata for WasmSqlite { diff --git a/diesel-wasm-sqlite/src/connection/mod.rs b/diesel-wasm-sqlite/src/connection/mod.rs index 46097c0e8..5ec7e694e 100644 --- a/diesel-wasm-sqlite/src/connection/mod.rs +++ b/diesel-wasm-sqlite/src/connection/mod.rs @@ -11,7 +11,7 @@ mod stmt; pub(crate) use self::bind_collector::SqliteBindCollector; pub use self::bind_collector::SqliteBindValue; // pub use self::serialized_database::SerializedDatabase; -// pub use self::sqlite_value::SqliteValue; +pub use self::sqlite_value::SqliteValue; /* use self::raw::RawConnection; @@ -44,7 +44,7 @@ use std::{ task::{Context, Poll}, }; -use crate::{get_sqlite, get_sqlite_unchecked, WasmSqlite, WasmSqliteError}; +use crate::{get_sqlite_unchecked, WasmSqlite, WasmSqliteError}; use std::future::Ready; unsafe impl Send for WasmSqliteConnection {} diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs index 8a1d2beb4..cd971af49 100644 --- a/diesel-wasm-sqlite/src/connection/raw.rs +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -78,7 +78,7 @@ impl RawConnection { fn_name: &str, num_args: i32, deterministic: bool, - mut f: F, + f: F, ) -> QueryResult<()> where F: FnMut(JsValue, JsValue) + 'static, diff --git a/diesel-wasm-sqlite/src/connection/row.rs b/diesel-wasm-sqlite/src/connection/row.rs index 3d9f1d94f..268571ba1 100644 --- a/diesel-wasm-sqlite/src/connection/row.rs +++ b/diesel-wasm-sqlite/src/connection/row.rs @@ -66,7 +66,7 @@ impl<'stmt, 'query> PrivateSqliteRow<'stmt, 'query> { } => PrivateSqliteRow::Duplicated { values: values .iter() - .map(|v| v.as_ref().map(|v| v.duplicate())) + .map(|v| v.as_ref().map(|v| v.clone())) .collect(), column_names: column_names.clone(), }, @@ -120,7 +120,7 @@ impl<'stmt, 'query> PrivateSqliteRow<'stmt, 'query> { OwnedSqliteRow::new( values .iter() - .map(|v| v.as_ref().map(|v| v.duplicate())) + .map(|v| v.as_ref().map(|v| v.clone())) .collect(), column_names, ) diff --git a/diesel-wasm-sqlite/src/connection/sqlite_value.rs b/diesel-wasm-sqlite/src/connection/sqlite_value.rs index d59febf59..6b2413bdf 100644 --- a/diesel-wasm-sqlite/src/connection/sqlite_value.rs +++ b/diesel-wasm-sqlite/src/connection/sqlite_value.rs @@ -1,8 +1,8 @@ #![allow(unsafe_code)] // ffi calls use std::cell::Ref; -use std::{slice, str}; +use crate::ffi::{self, SQLiteCompatibleType}; use crate::{backend::SqliteType, sqlite_types}; use wasm_bindgen::JsValue; @@ -27,12 +27,12 @@ pub struct SqliteValue<'row, 'stmt, 'query> { // This is sound as long as nobody calls `stmt.step()` // while holding this value. We ensure this by including // a reference to the row above. - value: JsValue, + value: SQLiteCompatibleType, } #[derive(Debug, Clone)] pub(super) struct OwnedSqliteValue { - pub(super) value: JsValue, + pub(super) value: SQLiteCompatibleType, } // Unsafe Send impl safe since sqlite3_value is built with sqlite3_value_dup @@ -46,9 +46,11 @@ impl<'row, 'stmt, 'query> SqliteValue<'row, 'stmt, 'query> { ) -> Option> { let value = match &*row { PrivateSqliteRow::Direct(stmt) => stmt.column_value(col_idx)?, - PrivateSqliteRow::Duplicated { values, .. } => { - values.get(col_idx as usize).and_then(|v| v.as_ref())?.value - } + PrivateSqliteRow::Duplicated { values, .. } => values + .get(col_idx as usize) + .and_then(|v| v.as_ref())? + .value + .clone(), }; let ret = Self { @@ -70,7 +72,8 @@ impl<'row, 'stmt, 'query> SqliteValue<'row, 'stmt, 'query> { .values .get(col_idx as usize) .and_then(|v| v.as_ref())? - .value; + .value + .clone(); let ret = Self { _row: None, value }; if ret.value_type().is_none() { None @@ -79,57 +82,48 @@ impl<'row, 'stmt, 'query> SqliteValue<'row, 'stmt, 'query> { } } - pub(crate) fn parse_string<'value, R>(&'value self, f: impl FnOnce(&'value str) -> R) -> R { - let s = unsafe { - let ptr = ffi::sqlite3_value_text(self.value.as_ptr()); - let len = ffi::sqlite3_value_bytes(self.value.as_ptr()); - let bytes = slice::from_raw_parts(ptr, len as usize); - // The string is guaranteed to be utf8 according to - // https://www.sqlite.org/c3ref/value_blob.html - str::from_utf8_unchecked(bytes) - }; + pub(crate) fn parse_string(&self, f: impl FnOnce(String) -> R) -> R { + let sqlite3 = crate::get_sqlite_unchecked(); + let s = sqlite3.value_text(&self.value); f(s) } - pub(crate) fn read_text(&self) -> &str { + // TODO: Wasm bindgen can't work with references yet + // not sure if this will effect perf + pub(crate) fn read_text(&self) -> String { self.parse_string(|s| s) } - pub(crate) fn read_blob(&self) -> &[u8] { - unsafe { - let ptr = ffi::sqlite3_value_blob(self.value.as_ptr()); - let len = ffi::sqlite3_value_bytes(self.value.as_ptr()); - if len == 0 { - // rusts std-lib has an debug_assert that prevents creating - // slices without elements from a pointer - &[] - } else { - slice::from_raw_parts(ptr as *const u8, len as usize) - } - } + pub(crate) fn read_blob(&self) -> Vec { + let sqlite3 = crate::get_sqlite_unchecked(); + sqlite3.value_blob(&self.value) } pub(crate) fn read_integer(&self) -> i32 { - unsafe { ffi::sqlite3_value_int(self.value.as_ptr()) } + let sqlite3 = crate::get_sqlite_unchecked(); + sqlite3.value_int(&self.value) } pub(crate) fn read_long(&self) -> i64 { - unsafe { ffi::sqlite3_value_int64(self.value.as_ptr()) } + let sqlite3 = crate::get_sqlite_unchecked(); + sqlite3.value_int64(&self.value) } pub(crate) fn read_double(&self) -> f64 { - unsafe { ffi::sqlite3_value_double(self.value.as_ptr()) } + let sqlite3 = crate::get_sqlite_unchecked(); + sqlite3.value_double(&self.value) } /// Get the type of the value as returned by sqlite pub fn value_type(&self) -> Option { - let tpe = unsafe { ffi::sqlite3_value_type(self.value.as_ptr()) }; + let sqlite3 = crate::get_sqlite_unchecked(); + let tpe = sqlite3.value_type(&self.value); match tpe { - ffi::SQLITE_TEXT => Some(SqliteType::Text), - ffi::SQLITE_INTEGER => Some(SqliteType::Long), - ffi::SQLITE_FLOAT => Some(SqliteType::Double), - ffi::SQLITE_BLOB => Some(SqliteType::Binary), - ffi::SQLITE_NULL => None, + sqlite_types::SQLITE_TEXT => Some(SqliteType::Text), + sqlite_types::SQLITE_INTEGER => Some(SqliteType::Long), + sqlite_types::SQLITE_FLOAT => Some(SqliteType::Double), + sqlite_types::SQLITE_BLOB => Some(SqliteType::Binary), + sqlite_types::SQLITE_NULL => None, _ => unreachable!( "Sqlite's documentation state that this case ({}) is not reachable. \ If you ever see this error message please open an issue at \ @@ -141,14 +135,30 @@ impl<'row, 'stmt, 'query> SqliteValue<'row, 'stmt, 'query> { } impl OwnedSqliteValue { - pub(super) fn new_from_ptr(ptr: &JsValue) -> Option { + pub(super) fn copy_from_ptr(ptr: &JsValue) -> Option { let sqlite3 = crate::get_sqlite_unchecked(); - let value = sqlite3.value(ptr); - - if value.is_null() { + let tpe = sqlite3.value_type(&ptr); + if sqlite_types::SQLITE_NULL == tpe { return None; } - Some(Self { value }) + let value = sqlite3.value_dup(ptr); + + Some(Self { + value: value.into(), + }) + } + + /* + pub(super) fn copy_from_ptr(ptr: NonNull) -> Option { + let tpe = unsafe { ffi::sqlite3_value_type(ptr.as_ptr()) }; + if ffi::SQLITE_NULL == tpe { + return None; + } + let value = unsafe { ffi::sqlite3_value_dup(ptr.as_ptr()) }; + Some(Self { + value: NonNull::new(value)?, + }) } + */ } diff --git a/diesel-wasm-sqlite/src/connection/stmt.rs b/diesel-wasm-sqlite/src/connection/stmt.rs index 68b03c871..997994d95 100644 --- a/diesel-wasm-sqlite/src/connection/stmt.rs +++ b/diesel-wasm-sqlite/src/connection/stmt.rs @@ -2,8 +2,9 @@ use super::bind_collector::{InternalSqliteBindValue, SqliteBindCollector}; use super::raw::RawConnection; use super::sqlite_value::OwnedSqliteValue; +use crate::ffi::SQLiteCompatibleType; use crate::{ - sqlite_types::{result_codes, PrepareOptions, SqlitePrepareFlags}, + sqlite_types::{self, PrepareOptions, SqlitePrepareFlags}, SqliteType, WasmSqlite, }; use diesel::{ @@ -44,7 +45,7 @@ impl Statement { .prepare( &raw_connection.internal_connection, sql, - Some(serde_wasm_bindgen::to_value(&options).unwrap()), + serde_wasm_bindgen::to_value(&options).unwrap(), ) .await .unwrap(); @@ -77,83 +78,8 @@ impl Statement { // sqlite3. However, not sure how this will work further up the stack. // This might not work because of differences in how serde_json recognizes js types // and how wa-sqlite recogizes js types. In that case, need to resort to matching on - // individual types as below. - /* - let result = match (tpe, value) { - (_, InternalSqliteBindValue::Null) => { - ffi::sqlite3_bind_null(self.inner_statement.as_ptr(), bind_index) - } - (SqliteType::Binary, InternalSqliteBindValue::BorrowedBinary(bytes)) => { - ffi::sqlite3_bind_blob( - self.inner_statement.as_ptr(), - bind_index, - bytes.as_ptr() as *const libc::c_void, - bytes.len() as libc::c_int, - ffi::SQLITE_STATIC(), - ) - } - (SqliteType::Binary, InternalSqliteBindValue::Binary(mut bytes)) => { - let len = bytes.len(); - // We need a separate pointer here to pass it to sqlite - // as the returned pointer is a pointer to a dyn sized **slice** - // and not the pointer to the first element of the slice - let ptr = bytes.as_mut_ptr(); - ret_ptr = NonNull::new(Box::into_raw(bytes)); - ffi::sqlite3_bind_blob( - self.inner_statement.as_ptr(), - bind_index, - ptr as *const libc::c_void, - len as libc::c_int, - ffi::SQLITE_STATIC(), - ) - } - (SqliteType::Text, InternalSqliteBindValue::BorrowedString(bytes)) => { - ffi::sqlite3_bind_text( - self.inner_statement.as_ptr(), - bind_index, - bytes.as_ptr() as *const libc::c_char, - bytes.len() as libc::c_int, - ffi::SQLITE_STATIC(), - ) - } - (SqliteType::Text, InternalSqliteBindValue::String(bytes)) => { - let mut bytes = Box::<[u8]>::from(bytes); - let len = bytes.len(); - // We need a separate pointer here to pass it to sqlite - // as the returned pointer is a pointer to a dyn sized **slice** - // and not the pointer to the first element of the slice - let ptr = bytes.as_mut_ptr(); - ret_ptr = NonNull::new(Box::into_raw(bytes)); - ffi::sqlite3_bind_text( - self.inner_statement.as_ptr(), - bind_index, - ptr as *const libc::c_char, - len as libc::c_int, - ffi::SQLITE_STATIC(), - ) - } - (SqliteType::Float, InternalSqliteBindValue::F64(value)) - | (SqliteType::Double, InternalSqliteBindValue::F64(value)) => { - ffi::sqlite3_bind_double( - self.inner_statement.as_ptr(), - bind_index, - value as libc::c_double, - ) - } - (SqliteType::SmallInt, InternalSqliteBindValue::I32(value)) - | (SqliteType::Integer, InternalSqliteBindValue::I32(value)) => { - ffi::sqlite3_bind_int(self.inner_statement.as_ptr(), bind_index, value) - } - (SqliteType::Long, InternalSqliteBindValue::I64(value)) => { - ffi::sqlite3_bind_int64(self.inner_statement.as_ptr(), bind_index, value) - } - (t, b) => { - return Err(Error::SerializationError( - format!("Type mismatch: Expected {t:?}, got {b}").into(), - )) - } - } - */ + // individual types with bind_$type fns . + Ok(result) } @@ -370,13 +296,16 @@ impl<'stmt, 'query> StatementUse<'stmt, 'query> { // the cached column names pub(super) async fn step(&mut self, first_step: bool) -> QueryResult { let sqlite3 = crate::get_sqlite_unchecked(); - let res = match sqlite3 - .step(&self.statement.statement.inner_statement) - .await - .unwrap() + let res = match serde_wasm_bindgen::from_value::( + sqlite3 + .step(&self.statement.statement.inner_statement) + .await + .unwrap(), + ) + .unwrap() { - result_codes::SQLITE_DONE => Ok(false), - result_codes::SQLITE_ROW => Ok(true), + sqlite_types::SQLITE_DONE => Ok(false), + sqlite_types::SQLITE_ROW => Ok(true), _ => panic!("SQLite Step returned Unhandled Result Code. Turn into err message"), }; @@ -422,18 +351,15 @@ impl<'stmt, 'query> StatementUse<'stmt, 'query> { column_names.get(idx as usize).map(AsRef::as_ref) } - /* + pub(super) fn copy_value(&self, idx: i32) -> Option { - OwnedSqliteValue::copy_from_ptr(self.column_value(idx)?) + OwnedSqliteValue::copy_from_ptr(&self.column_value(idx)?.into()) } - pub(super) fn column_value(&self, idx: i32) -> Option> { - let ptr = unsafe { - ffi::sqlite3_column_value(self.statement.statement.inner_statement.as_ptr(), idx) - }; - NonNull::new(ptr) + pub(super) fn column_value(&self, idx: i32) -> Option { + let sqlite3 = crate::get_sqlite_unchecked(); + Some(sqlite3.column(&self.statement.statement.inner_statement, idx)) } - */ } #[cfg(test)] diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index 1cee7ce27..c44426e39 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -12,6 +12,27 @@ extern "C" { } */ +/* once https://github.com/rust-lang/rust/issues/128183 is merged this would work +pub mod consts { + pub const SQLITE_INTEGER: i32 = super::SQLITE_INTEGER; +} +*/ + +// Constants +#[wasm_bindgen(module = "/src/wa-sqlite-diesel-bundle.js")] +extern "C" { + pub static SqliteDone: i32; + pub static SqliteRow: i32; + + // Fundamental datatypes. + // https://www.sqlite.org/c3ref/c_blob.html + pub static SQLITE_INTEGER: i32; + pub static SQLITE_FLOAT: i32; + pub static SQLITE_TEXT: i32; + pub static SQLITE_BLOB: i32; + pub static SQLITE_NULL: i32; +} + // WASM is ran in the browser `main thread`. Tokio is only a single-threaded runtime. // We need SQLite available globally, so this should be ok until we get threads with WASI or // something. At which point we can (hopefully) use multi-threaded async runtime to block the @@ -23,6 +44,7 @@ unsafe impl Sync for SQLite {} #[wasm_bindgen(module = "/src/wa-sqlite-diesel-bundle.js")] extern "C" { pub type SQLite; + #[derive(Debug, Clone)] pub type SQLiteCompatibleType; // pub type SqlitePrepareOptions; @@ -102,7 +124,32 @@ extern "C" { pub async fn reset(this: &SQLite, stmt: &JsValue) -> Result; #[wasm_bindgen(method)] - pub fn value(this: &SQLite, pValue: &JsValue); + pub fn value(this: &SQLite, pValue: &JsValue) -> SQLiteCompatibleType; + + #[wasm_bindgen(method)] + pub fn value_dup(this: &SQLite, pValue: &JsValue) -> JsValue; + + #[wasm_bindgen(method)] + pub fn value_blob(this: &SQLite, pValue: &JsValue) -> Vec; + + #[wasm_bindgen(method)] + pub fn value_bytes(this: &SQLite, pValue: &JsValue) -> i32; + + #[wasm_bindgen(method)] + pub fn value_double(this: &SQLite, pValue: &JsValue) -> f64; + + #[wasm_bindgen(method)] + pub fn value_int(this: &SQLite, pValue: &JsValue) -> i32; + + #[wasm_bindgen(method)] + pub fn value_int64(this: &SQLite, pValue: &JsValue) -> i64; + + // TODO: If wasm-bindgen allows returning references, could return &str + #[wasm_bindgen(method)] + pub fn value_text(this: &SQLite, pValue: &JsValue) -> String; + + #[wasm_bindgen(method)] + pub fn value_type(this: &SQLite, pValue: &JsValue) -> i32; #[wasm_bindgen(method, catch)] pub async fn open_v2( @@ -121,17 +168,23 @@ extern "C" { pub fn changes(this: &SQLite, database: &JsValue) -> usize; #[wasm_bindgen(method, catch)] - pub async fn step(this: &SQLite, stmt: &JsValue) -> Result; + pub async fn step(this: &SQLite, stmt: &JsValue) -> Result; #[wasm_bindgen(method, catch)] pub fn clear_bindings(this: &SQLite, stmt: &JsValue) -> Result; + #[wasm_bindgen(method, catch)] + pub async fn close(this: &SQLite, database: &JsValue) -> Result<(), JsValue>; + + #[wasm_bindgen(method)] + pub fn column(this: &SQLite, stmt: &JsValue, idx: i32) -> SQLiteCompatibleType; + #[wasm_bindgen(method, catch)] pub async fn prepare( this: &SQLite, database: &JsValue, sql: &str, - options: Option, + options: JsValue, ) -> Result; #[wasm_bindgen(method)] diff --git a/diesel-wasm-sqlite/src/sqlite_types.rs b/diesel-wasm-sqlite/src/sqlite_types.rs index a8304483d..1d2066976 100644 --- a/diesel-wasm-sqlite/src/sqlite_types.rs +++ b/diesel-wasm-sqlite/src/sqlite_types.rs @@ -3,10 +3,21 @@ use bitflags::bitflags; use diesel::sql_types::*; use serde::{Deserialize, Serialize}; -pub mod result_codes { - pub const SQLITE_DONE: i32 = 101; - pub const SQLITE_ROW: i32 = 100; -} +//TODO These Database Types are defined in the wasm file and should be imported. +// this is easier for now because of quirks with converting from JsValue to integer within extern +// "C" declaration. + +// result codes +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_ROW: i32 = 100; + +// Fundamental datatypes. +// https://www.sqlite.org/c3ref/c_blob.html +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; /// `SqlitePrepareOptions` imported type #[derive(Serialize, Deserialize, Default, Clone, Debug, Copy)] diff --git a/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js index 8c94e8a90..2a671e661 100644 --- a/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js +++ b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js @@ -2855,6 +2855,38 @@ class SQLite { this.sqlite3.value(pValue); } + value_dup(pValue) { + return this.module._sqlite3_value_dup(pValue); + } + + value_blob(pValue) { + this.sqlite3.value_blob(pValue); + } + + value_bytes(pValue) { + this.sqlite3.value_bytes(pValue); + } + + value_double(pValue) { + this.sqlite3.value_double(pValue); + } + + value_int(pValue) { + this.sqlite3.value_int(pValue); + } + + value_int64(pValue) { + this.sqlite3.value_int64(pValue); + } + + value_text(pValue) { + this.sqlite3.value_text(pValue); + } + + value_type(pValue) { + this.sqlite3.value_type(pValue); + } + async open_v2(database_url, iflags) { try { console.log("Opening database!", database_url); @@ -2892,6 +2924,19 @@ class SQLite { return this.sqlite3.clear_bindings(stmt); } + async close(db) { + try { + return this.sqlite3.close(db); + } catch (error) { + console.log("sqlite3.close error"); + throw error; + } + } + + column(stmt, i) { + return this.sqlite3.column(stmt, i); + } + async prepare(database, sql, options) { try { return await this.sqlite3.statements(database, sql, options); From b992287e2a9b3ccad5f4d6e50a865347ad077319 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Tue, 6 Aug 2024 15:57:09 -0400 Subject: [PATCH 20/28] replace placeholders with real values --- diesel-wasm-sqlite/Cargo.lock | 1 + diesel-wasm-sqlite/Cargo.toml | 1 + diesel-wasm-sqlite/src/connection/mod.rs | 116 ++---------------- diesel-wasm-sqlite/src/connection/row.rs | 4 +- .../src/connection/sqlite_value.rs | 15 +-- diesel-wasm-sqlite/src/ffi.rs | 2 +- 6 files changed, 23 insertions(+), 116 deletions(-) diff --git a/diesel-wasm-sqlite/Cargo.lock b/diesel-wasm-sqlite/Cargo.lock index 171c620d6..7c3889c6e 100644 --- a/diesel-wasm-sqlite/Cargo.lock +++ b/diesel-wasm-sqlite/Cargo.lock @@ -160,6 +160,7 @@ dependencies = [ "diesel", "diesel-async", "futures", + "futures-util", "getrandom", "log", "rand", diff --git a/diesel-wasm-sqlite/Cargo.toml b/diesel-wasm-sqlite/Cargo.toml index 555aee523..d844be5c7 100644 --- a/diesel-wasm-sqlite/Cargo.toml +++ b/diesel-wasm-sqlite/Cargo.toml @@ -17,6 +17,7 @@ web-sys = { version = "0.3", features = ["console"] } console_error_panic_hook = { version = "0.1", optional = true } tokio = { version = "1.38", default-features = false, features = ["rt", "macros", "sync", "io-util", "time"] } futures = "0.3" +futures-util = "0.3" async-trait = "0.1" bitflags = "2.6" serde = { version = "1.0", features = ["derive"] } diff --git a/diesel-wasm-sqlite/src/connection/mod.rs b/diesel-wasm-sqlite/src/connection/mod.rs index 5ec7e694e..a4029d1a2 100644 --- a/diesel-wasm-sqlite/src/connection/mod.rs +++ b/diesel-wasm-sqlite/src/connection/mod.rs @@ -10,8 +10,8 @@ mod stmt; pub(crate) use self::bind_collector::SqliteBindCollector; pub use self::bind_collector::SqliteBindValue; -// pub use self::serialized_database::SerializedDatabase; pub use self::sqlite_value::SqliteValue; + // pub use self::serialized_database::SerializedDatabase; /* use self::raw::RawConnection; @@ -20,32 +20,20 @@ use self::stmt::{Statement, StatementUse}; use super::SqliteAggregateFunction; use crate::connection::instrumentation::StrQueryHelper; use crate::connection::statement_cache::StatementCache; -use crate::connection::*; use crate::query_builder::*; -use crate::sqlite::WasmSqlite; use diesel::deserialize::{FromSqlRow, StaticallySizedRow}; use diesel::expression::QueryMetadata; use diesel::result::*; use diesel::serialize::ToSql; use diesel::sql_types::{HasSqlType, TypeMetadata}; */ -use diesel::{ - backend::Backend, - connection::Instrumentation, - query_builder::{AsQuery, QueryFragment, QueryId}, - result::QueryResult, - row::Field, -}; + +use diesel::{connection::Instrumentation, query_builder::{AsQuery, QueryFragment, QueryId}, QueryResult}; pub use diesel_async::{AnsiTransactionManager, AsyncConnection, SimpleAsyncConnection}; -use futures::stream::Stream; -use std::{ - marker::PhantomData, - pin::Pin, - task::{Context, Poll}, -}; +use futures::{future::BoxFuture, stream::BoxStream}; +use row::SqliteRow; use crate::{get_sqlite_unchecked, WasmSqlite, WasmSqliteError}; -use std::future::Ready; unsafe impl Send for WasmSqliteConnection {} #[derive(Debug)] @@ -63,94 +51,16 @@ impl SimpleAsyncConnection for WasmSqliteConnection { } } -/// TODO: The placeholder stuff all needs to be re-done -pub struct OwnedSqliteFieldPlaceholder<'field> { - field: PhantomData<&'field ()>, -} - -impl<'f> Field<'f, WasmSqlite> for OwnedSqliteFieldPlaceholder<'f> { - fn field_name(&self) -> Option<&str> { - Some("placeholder") - } - fn value(&self) -> Option<::RawValue<'_>> { - todo!() - } -} - -pub struct InnerPartialRowPlaceholder; - -pub struct RowReady(Option<()>); - -impl std::future::Future for RowReady { - type Output = (); - - fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - Poll::Ready(self.0.take().expect("`Ready` polled after completion")) - } -} - -impl diesel::row::RowSealed for RowReady {} - -impl<'a, 'b> diesel::row::RowIndex<&'a str> for RowReady { - fn idx(&self, idx: &'a str) -> Option { - todo!() - } -} - -impl diesel::row::RowIndex for RowReady { - fn idx(&self, idx: usize) -> Option { - todo!() - } -} - -impl<'a> diesel::row::Row<'a, WasmSqlite> for RowReady { - type Field<'f> = OwnedSqliteFieldPlaceholder<'f> - where - 'a: 'f, - Self: 'f; - - type InnerPartialRow = Self; - - fn field_count(&self) -> usize { - todo!() - } - - fn get<'b, I>(&'b self, idx: I) -> Option> - where - 'a: 'b, - Self: diesel::row::RowIndex, - { - todo!() - } - - fn partial_row( - &self, - range: std::ops::Range, - ) -> diesel::row::PartialRow<'_, Self::InnerPartialRow> { - todo!() - } -} - -pub struct RowReadyStreamPlaceholder; - -impl Stream for RowReadyStreamPlaceholder { - type Item = QueryResult; - fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { - todo!(); - } -} - impl diesel::connection::ConnectionSealed for WasmSqliteConnection {} #[async_trait::async_trait(?Send)] impl AsyncConnection for WasmSqliteConnection { type Backend = WasmSqlite; type TransactionManager = AnsiTransactionManager; - // placeholders - type ExecuteFuture<'conn, 'query> = Ready>; - type LoadFuture<'conn, 'query> = Ready>>; - type Stream<'conn, 'query> = RowReadyStreamPlaceholder; - type Row<'conn, 'query> = RowReady; + type ExecuteFuture<'conn, 'query> = BoxFuture<'query, QueryResult>; + type LoadFuture<'conn, 'query> = BoxFuture<'query, QueryResult>>; + type Stream<'conn, 'query> = BoxStream<'static, QueryResult>>; + type Row<'conn, 'query> = SqliteRow<'conn, 'query>; async fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { Ok(WasmSqliteConnection { @@ -158,7 +68,7 @@ impl AsyncConnection for WasmSqliteConnection { }) } - fn load<'conn, 'query, T>(&'conn mut self, source: T) -> Self::LoadFuture<'conn, 'query> + fn load<'conn, 'query, T>(&'conn mut self, _source: T) -> Self::LoadFuture<'conn, 'query> where T: AsQuery + 'query, T::Query: QueryFragment + QueryId + 'query, @@ -168,14 +78,14 @@ impl AsyncConnection for WasmSqliteConnection { fn execute_returning_count<'conn, 'query, T>( &'conn mut self, - source: T, + _source: T, ) -> Self::ExecuteFuture<'conn, 'query> where T: QueryFragment + QueryId + 'query, { todo!() } - + fn transaction_state( &mut self, ) -> &mut >::TransactionStateData{ @@ -186,7 +96,7 @@ impl AsyncConnection for WasmSqliteConnection { todo!() } - fn set_instrumentation(&mut self, instrumentation: impl Instrumentation) { + fn set_instrumentation(&mut self, _instrumentation: impl Instrumentation) { todo!() } } diff --git a/diesel-wasm-sqlite/src/connection/row.rs b/diesel-wasm-sqlite/src/connection/row.rs index 268571ba1..3d9f1d94f 100644 --- a/diesel-wasm-sqlite/src/connection/row.rs +++ b/diesel-wasm-sqlite/src/connection/row.rs @@ -66,7 +66,7 @@ impl<'stmt, 'query> PrivateSqliteRow<'stmt, 'query> { } => PrivateSqliteRow::Duplicated { values: values .iter() - .map(|v| v.as_ref().map(|v| v.clone())) + .map(|v| v.as_ref().map(|v| v.duplicate())) .collect(), column_names: column_names.clone(), }, @@ -120,7 +120,7 @@ impl<'stmt, 'query> PrivateSqliteRow<'stmt, 'query> { OwnedSqliteRow::new( values .iter() - .map(|v| v.as_ref().map(|v| v.clone())) + .map(|v| v.as_ref().map(|v| v.duplicate())) .collect(), column_names, ) diff --git a/diesel-wasm-sqlite/src/connection/sqlite_value.rs b/diesel-wasm-sqlite/src/connection/sqlite_value.rs index 6b2413bdf..e94e77217 100644 --- a/diesel-wasm-sqlite/src/connection/sqlite_value.rs +++ b/diesel-wasm-sqlite/src/connection/sqlite_value.rs @@ -149,16 +149,11 @@ impl OwnedSqliteValue { }) } - /* - pub(super) fn copy_from_ptr(ptr: NonNull) -> Option { - let tpe = unsafe { ffi::sqlite3_value_type(ptr.as_ptr()) }; - if ffi::SQLITE_NULL == tpe { - return None; + pub(super) fn duplicate(&self) -> OwnedSqliteValue { + let sqlite3 = crate::get_sqlite_unchecked(); + let value = sqlite3.value_dup(&self.value); + OwnedSqliteValue { + value: value.into(), } - let value = unsafe { ffi::sqlite3_value_dup(ptr.as_ptr()) }; - Some(Self { - value: NonNull::new(value)?, - }) } - */ } diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index c44426e39..6d011e95c 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -127,7 +127,7 @@ extern "C" { pub fn value(this: &SQLite, pValue: &JsValue) -> SQLiteCompatibleType; #[wasm_bindgen(method)] - pub fn value_dup(this: &SQLite, pValue: &JsValue) -> JsValue; + pub fn value_dup(this: &SQLite, pValue: &JsValue) -> SQLiteCompatibleType; #[wasm_bindgen(method)] pub fn value_blob(this: &SQLite, pValue: &JsValue) -> Vec; From 4dc9e1f874a4693891180ed90a601fbf12cb2ea5 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Mon, 12 Aug 2024 12:30:52 -0400 Subject: [PATCH 21/28] compile w/o prepared statements or SQLite custom fns --- diesel-wasm-sqlite/Cargo.lock | 10 +- diesel-wasm-sqlite/Cargo.toml | 2 +- diesel-wasm-sqlite/package.js | 19 +- .../src/connection/functions.rs | 106 ++++---- diesel-wasm-sqlite/src/connection/mod.rs | 244 ++++++------------ diesel-wasm-sqlite/src/connection/raw.rs | 50 +++- .../src/connection/serialized_database.rs | 5 +- diesel-wasm-sqlite/src/connection/stmt.rs | 48 +++- diesel-wasm-sqlite/src/ffi.rs | 5 +- diesel-wasm-sqlite/src/lib.rs | 0 .../src/wa-sqlite-diesel-bundle.js | 19 +- 11 files changed, 258 insertions(+), 250 deletions(-) mode change 100644 => 100755 diesel-wasm-sqlite/src/lib.rs diff --git a/diesel-wasm-sqlite/Cargo.lock b/diesel-wasm-sqlite/Cargo.lock index 7c3889c6e..8a32aca0c 100644 --- a/diesel-wasm-sqlite/Cargo.lock +++ b/diesel-wasm-sqlite/Cargo.lock @@ -75,9 +75,9 @@ checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50" [[package]] name = "cc" -version = "1.1.7" +version = "1.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26a5c3fd7bfa1ce3897a3a3501d362b2d87b7f2583ebcb4a949ec25911025cbc" +checksum = "504bdec147f2cc13c8b57ed9401fd8a147cc66b67ad5cb241394244f2c947549" [[package]] name = "cfg-if" @@ -142,7 +142,7 @@ dependencies = [ [[package]] name = "diesel-async" version = "0.5.0" -source = "git+https://github.com/insipx/diesel_async?branch=insipx/wasm-async#c255cddfecec3597fb102cfa85494f6e23cb6b9b" +source = "git+https://github.com/insipx/diesel_async?branch=insipx/make-stmt-cache-public#2cd189fb9300dcaeb204d05526cc9b0e079096c2" dependencies = [ "async-trait", "diesel", @@ -379,9 +379,9 @@ dependencies = [ [[package]] name = "object" -version = "0.36.2" +version = "0.36.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f203fa8daa7bb185f760ae12bd8e097f63d17041dcdcaf675ac54cdf863170e" +checksum = "27b64972346851a39438c60b341ebc01bba47464ae329e55cf343eb93964efd9" dependencies = [ "memchr", ] diff --git a/diesel-wasm-sqlite/Cargo.toml b/diesel-wasm-sqlite/Cargo.toml index d844be5c7..737e6d77d 100644 --- a/diesel-wasm-sqlite/Cargo.toml +++ b/diesel-wasm-sqlite/Cargo.toml @@ -6,7 +6,7 @@ edition = "2021" [dependencies] # diesel = { git = "https://github.com/xmtp/diesel", branch = "insipx/wasm-backend", default-features = false, features = ["i-implement-a-third-party-backend-and-opt-into-breaking-changes"] } diesel = "2.2" -diesel-async = { git = "https://github.com/insipx/diesel_async", branch = "insipx/wasm-async" } +diesel-async = { git = "https://github.com/insipx/diesel_async", branch = "insipx/make-stmt-cache-public", features = ["stmt-cache"] } wasm-bindgen = "0.2.92" wasm-bindgen-futures = "0.4.42" log = "0.4" diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index ca65d63e9..7c4e4b335 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -273,14 +273,23 @@ export class SQLite { } } - create_function(database, functionName, nArg, textRep, xFunc, xStep, xFinal) { + create_function( + database, + functionName, + nArg, + textRep, + pApp, + xFunc, + xStep, + xFinal, + ) { try { sqlite.create_function( database, functionName, nArg, textRep, - 0, + pApp, // pApp is ignored xFunc, xStep, xFinal, @@ -290,4 +299,10 @@ export class SQLite { console.log("create function err"); } } + + /* + serialize(database, zSchema, size, flags) { + return this.module._sqlite3_serialize(database, zSchema, size, flags); + } + */ } diff --git a/diesel-wasm-sqlite/src/connection/functions.rs b/diesel-wasm-sqlite/src/connection/functions.rs index db330ee23..b8d8f7538 100644 --- a/diesel-wasm-sqlite/src/connection/functions.rs +++ b/diesel-wasm-sqlite/src/connection/functions.rs @@ -1,22 +1,23 @@ -extern crate libsqlite3_sys as ffi; - use super::raw::RawConnection; use super::row::PrivateSqliteRow; -use super::{Sqlite, SqliteAggregateFunction, SqliteBindValue}; -use crate::backend::Backend; -use crate::deserialize::{FromSqlRow, StaticallySizedRow}; -use crate::result::{DatabaseErrorKind, Error, QueryResult}; -use crate::row::{Field, PartialRow, Row, RowIndex, RowSealed}; -use crate::serialize::{IsNull, Output, ToSql}; -use crate::sql_types::HasSqlType; -use crate::sqlite::connection::bind_collector::InternalSqliteBindValue; -use crate::sqlite::connection::sqlite_value::OwnedSqliteValue; -use crate::sqlite::SqliteValue; +use super::{/*SqliteAggregateFunction,*/ SqliteBindValue, WasmSqlite}; +use crate::connection::bind_collector::InternalSqliteBindValue; +use crate::connection::sqlite_value::OwnedSqliteValue; +use crate::connection::SqliteValue; +use diesel::backend::Backend; +use diesel::deserialize::{FromSqlRow, StaticallySizedRow}; +use diesel::result::{DatabaseErrorKind, Error, QueryResult}; +use diesel::row::{Field, PartialRow, Row, RowIndex, RowSealed}; +use diesel::serialize::{IsNull, Output, ToSql}; +use diesel::sql_types::HasSqlType; +use futures::future::BoxFuture; +use futures::FutureExt; use std::cell::{Ref, RefCell}; use std::marker::PhantomData; use std::mem::ManuallyDrop; use std::ops::DerefMut; use std::rc::Rc; +use wasm_bindgen::JsValue; pub(super) fn register( conn: &RawConnection, @@ -25,10 +26,10 @@ pub(super) fn register( mut f: F, ) -> QueryResult<()> where - F: FnMut(&RawConnection, Args) -> Ret + std::panic::UnwindSafe + Send + 'static, - Args: FromSqlRow + StaticallySizedRow, - Ret: ToSql, - Sqlite: HasSqlType, + F: FnMut(&RawConnection, Args) -> BoxFuture<'static, Ret>, + Args: FromSqlRow + StaticallySizedRow, + Ret: ToSql, + WasmSqlite: HasSqlType, { let fields_needed = Args::FIELD_COUNT; if fields_needed > 127 { @@ -39,13 +40,19 @@ where } conn.register_sql_function(fn_name, fields_needed, deterministic, move |conn, args| { - let args = build_sql_function_args::(args)?; - - Ok(f(conn, args)) + async { + let args = build_sql_function_args::(args)?; + let conn = RawConnection { + internal_connection: conn, + }; + Ok(f(&conn, args).await) + } + .boxed() })?; Ok(()) } +/* pub(super) fn register_noargs( conn: &RawConnection, fn_name: &str, @@ -54,8 +61,8 @@ pub(super) fn register_noargs( ) -> QueryResult<()> where F: FnMut() -> Ret + std::panic::UnwindSafe + Send + 'static, - Ret: ToSql, - Sqlite: HasSqlType, + Ret: ToSql, + WasmSqlite: HasSqlType, { conn.register_sql_function(fn_name, 0, deterministic, move |_, _| Ok(f()))?; Ok(()) @@ -67,9 +74,9 @@ pub(super) fn register_aggregate( ) -> QueryResult<()> where A: SqliteAggregateFunction + 'static + Send + std::panic::UnwindSafe, - Args: FromSqlRow + StaticallySizedRow, - Ret: ToSql, - Sqlite: HasSqlType, + Args: FromSqlRow + StaticallySizedRow, + Ret: ToSql, + WasmSqlite: HasSqlType, { let fields_needed = Args::FIELD_COUNT; if fields_needed > 127 { @@ -86,12 +93,11 @@ where Ok(()) } +*/ -pub(super) fn build_sql_function_args( - args: &mut [*mut ffi::sqlite3_value], -) -> Result +pub(super) fn build_sql_function_args(args: Vec) -> Result where - Args: FromSqlRow, + Args: FromSqlRow, { let row = FunctionRow::new(args); Args::build_from_row(&row).map_err(Error::DeserializationError) @@ -104,8 +110,8 @@ pub(super) fn process_sql_function_result( result: &'_ Ret, ) -> QueryResult> where - Ret: ToSql, - Sqlite: HasSqlType, + Ret: ToSql, + WasmSqlite: HasSqlType, { let mut metadata_lookup = (); let value = SqliteBindValue { @@ -126,7 +132,7 @@ struct FunctionRow<'a> { // as this buffer is owned by sqlite not by diesel args: Rc>>>, field_count: usize, - marker: PhantomData<&'a ffi::sqlite3_value>, + marker: PhantomData<&'a JsValue>, } impl<'a> Drop for FunctionRow<'a> { @@ -148,37 +154,17 @@ impl<'a> Drop for FunctionRow<'a> { impl<'a> FunctionRow<'a> { #[allow(unsafe_code)] // complicated ptr cast - fn new(args: &mut [*mut ffi::sqlite3_value]) -> Self { + fn new(args: Vec) -> Self { let lengths = args.len(); - let args = unsafe { - Vec::from_raw_parts( - // This cast is safe because: - // * Casting from a pointer to an array to a pointer to the first array - // element is safe - // * Casting from a raw pointer to `NonNull` is safe, - // because `NonNull` is #[repr(transparent)] - // * Casting from `NonNull` to `OwnedSqliteValue` is safe, - // as the struct is `#[repr(transparent)] - // * Casting from `NonNull` to `Option>` as the documentation - // states: "This is so that enums may use this forbidden value as a discriminant – - // Option> has the same size as *mut T" - // * The last point remains true for `OwnedSqliteValue` as `#[repr(transparent)] - // guarantees the same layout as the inner type - // * It's unsafe to drop the vector (and the vector elements) - // because of this we wrap the vector (or better the Row) - // Into `ManualDrop` to prevent the dropping - args as *mut [*mut ffi::sqlite3_value] as *mut ffi::sqlite3_value - as *mut Option, - lengths, - lengths, - ) - }; Self { field_count: lengths, args: Rc::new(RefCell::new(ManuallyDrop::new( PrivateSqliteRow::Duplicated { - values: args, + values: args + .into_iter() + .map(|a| Some(OwnedSqliteValue { value: a.into() })) + .collect(), column_names: Rc::from(vec![None; lengths]), }, ))), @@ -189,7 +175,7 @@ impl<'a> FunctionRow<'a> { impl RowSealed for FunctionRow<'_> {} -impl<'a> Row<'a, Sqlite> for FunctionRow<'a> { +impl<'a> Row<'a, WasmSqlite> for FunctionRow<'a> { type Field<'f> = FunctionArgument<'f> where 'a: 'f, Self: 'f; type InnerPartialRow = Self; @@ -200,7 +186,7 @@ impl<'a> Row<'a, Sqlite> for FunctionRow<'a> { fn get<'b, I>(&'b self, idx: I) -> Option> where 'a: 'b, - Self: crate::row::RowIndex, + Self: RowIndex, { let idx = self.idx(idx)?; Some(FunctionArgument { @@ -235,7 +221,7 @@ struct FunctionArgument<'a> { col_idx: i32, } -impl<'a> Field<'a, Sqlite> for FunctionArgument<'a> { +impl<'a> Field<'a, WasmSqlite> for FunctionArgument<'a> { fn field_name(&self) -> Option<&str> { None } @@ -244,7 +230,7 @@ impl<'a> Field<'a, Sqlite> for FunctionArgument<'a> { self.value().is_none() } - fn value(&self) -> Option<::RawValue<'_>> { + fn value(&self) -> Option<::RawValue<'_>> { SqliteValue::new( Ref::map(Ref::clone(&self.args), |drop| std::ops::Deref::deref(drop)), self.col_idx, diff --git a/diesel-wasm-sqlite/src/connection/mod.rs b/diesel-wasm-sqlite/src/connection/mod.rs index a4029d1a2..0fb898c86 100644 --- a/diesel-wasm-sqlite/src/connection/mod.rs +++ b/diesel-wasm-sqlite/src/connection/mod.rs @@ -12,47 +12,62 @@ pub(crate) use self::bind_collector::SqliteBindCollector; pub use self::bind_collector::SqliteBindValue; pub use self::sqlite_value::SqliteValue; // pub use self::serialized_database::SerializedDatabase; - -/* + use self::raw::RawConnection; -use self::statement_iterator::*; +// use self::statement_iterator::*; use self::stmt::{Statement, StatementUse}; -use super::SqliteAggregateFunction; -use crate::connection::instrumentation::StrQueryHelper; -use crate::connection::statement_cache::StatementCache; use crate::query_builder::*; +use diesel::connection::{DefaultLoadingMode, LoadConnection}; use diesel::deserialize::{FromSqlRow, StaticallySizedRow}; use diesel::expression::QueryMetadata; use diesel::result::*; use diesel::serialize::ToSql; -use diesel::sql_types::{HasSqlType, TypeMetadata}; -*/ +use diesel::sql_types::HasSqlType; +use futures::{FutureExt, TryFutureExt}; -use diesel::{connection::Instrumentation, query_builder::{AsQuery, QueryFragment, QueryId}, QueryResult}; -pub use diesel_async::{AnsiTransactionManager, AsyncConnection, SimpleAsyncConnection}; +use diesel::{connection::{ConnectionSealed, Instrumentation, WithMetadataLookup}, query_builder::{AsQuery, QueryFragment, QueryId}, sql_types::TypeMetadata, QueryResult}; +pub use diesel_async::{AnsiTransactionManager, AsyncConnection, SimpleAsyncConnection, TransactionManager, stmt_cache::StmtCache}; use futures::{future::BoxFuture, stream::BoxStream}; use row::SqliteRow; use crate::{get_sqlite_unchecked, WasmSqlite, WasmSqliteError}; -unsafe impl Send for WasmSqliteConnection {} -#[derive(Debug)] pub struct WasmSqliteConnection { - pub raw: raw::RawConnection, + // statement_cache needs to be before raw_connection + // otherwise we will get errors about open statements before closing the + // connection itself + statement_cache: StmtCache, + raw_connection: RawConnection, + transaction_state: AnsiTransactionManager, + // this exists for the sole purpose of implementing `WithMetadataLookup` trait + // and avoiding static mut which will be deprecated in 2024 edition + metadata_lookup: (), + instrumentation: Option>, } -#[async_trait::async_trait(?Send)] + +// This relies on the invariant that RawConnection or Statement are never +// leaked. If a reference to one of those was held on a different thread, this +// would not be thread safe. +// Web is in one thread. Web workers can be used to hold a WasmSqliteConnection +// separately. + +#[allow(unsafe_code)] +unsafe impl Send for WasmSqliteConnection {} + + +impl ConnectionSealed for WasmSqliteConnection {} + + #[async_trait::async_trait(?Send)] impl SimpleAsyncConnection for WasmSqliteConnection { async fn batch_execute(&mut self, query: &str) -> diesel::prelude::QueryResult<()> { get_sqlite_unchecked() - .batch_execute(&self.raw.internal_connection, query) + .batch_execute(&self.raw_connection.internal_connection, query) .map_err(WasmSqliteError::from) .map_err(Into::into) } } -impl diesel::connection::ConnectionSealed for WasmSqliteConnection {} - #[async_trait::async_trait(?Send)] impl AsyncConnection for WasmSqliteConnection { type Backend = WasmSqlite; @@ -64,7 +79,11 @@ impl AsyncConnection for WasmSqliteConnection { async fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { Ok(WasmSqliteConnection { - raw: raw::RawConnection::establish(database_url).await.unwrap(), + statement_cache: StmtCache::new(), + raw_connection: raw::RawConnection::establish(database_url).await.unwrap(), + transaction_state: Default::default(), + metadata_lookup: (), + instrumentation: None }) } @@ -102,99 +121,7 @@ impl AsyncConnection for WasmSqliteConnection { } /* -pub struct SqliteConnection { - // statement_cache needs to be before raw_connection - // otherwise we will get errors about open statements before closing the - // connection itself - statement_cache: StatementCache, - raw_connection: RawConnection, - transaction_state: AnsiTransactionManager, - // this exists for the sole purpose of implementing `WithMetadataLookup` trait - // and avoiding static mut which will be deprecated in 2024 edition - metadata_lookup: (), - instrumentation: Option>, -} -*/ - -// This relies on the invariant that RawConnection or Statement are never -// leaked. If a reference to one of those was held on a different thread, this -// would not be thread safe. -/* -#[allow(unsafe_code)] -unsafe impl Send for SqliteConnection {} - -impl SimpleConnection for SqliteConnection { - fn batch_execute(&mut self, query: &str) -> QueryResult<()> { - self.instrumentation - .on_connection_event(InstrumentationEvent::StartQuery { - query: &StrQueryHelper::new(query), - }); - let resp = self.raw_connection.exec(query); - self.instrumentation - .on_connection_event(InstrumentationEvent::FinishQuery { - query: &StrQueryHelper::new(query), - error: resp.as_ref().err(), - }); - resp - } -} -*/ -/* -impl ConnectionSealed for SqliteConnection {} - -impl Connection for SqliteConnection { - type Backend = Sqlite; - type TransactionManager = AnsiTransactionManager; - - /// Establish a connection to the database specified by `database_url`. - /// - /// See [SqliteConnection] for supported `database_url`. - /// - /// If the database does not exist, this method will try to - /// create a new database and then establish a connection to it. - fn establish(database_url: &str) -> ConnectionResult { - let mut instrumentation = crate::connection::instrumentation::get_default_instrumentation(); - instrumentation.on_connection_event(InstrumentationEvent::StartEstablishConnection { - url: database_url, - }); - - let establish_result = Self::establish_inner(database_url); - instrumentation.on_connection_event(InstrumentationEvent::FinishEstablishConnection { - url: database_url, - error: establish_result.as_ref().err(), - }); - let mut conn = establish_result?; - conn.instrumentation = instrumentation; - Ok(conn) - } - - fn execute_returning_count(&mut self, source: &T) -> QueryResult - where - T: QueryFragment + QueryId, - { - let statement_use = self.prepared_query(source)?; - statement_use - .run() - .map(|_| self.raw_connection.rows_affected_by_last_query()) - } - - fn transaction_state(&mut self) -> &mut AnsiTransactionManager - where - Self: Sized, - { - &mut self.transaction_state - } - - fn instrumentation(&mut self) -> &mut dyn Instrumentation { - &mut self.instrumentation - } - - fn set_instrumentation(&mut self, instrumentation: impl Instrumentation) { - self.instrumentation = Some(Box::new(instrumentation)); - } -} - -impl LoadConnection for SqliteConnection { +impl LoadConnection for WasmSqliteConnection { type Cursor<'conn, 'query> = StatementIterator<'conn, 'query>; type Row<'conn, 'query> = self::row::SqliteRow<'conn, 'query>; @@ -211,12 +138,14 @@ impl LoadConnection for SqliteConnection { Ok(StatementIterator::new(statement)) } } - -impl WithMetadataLookup for SqliteConnection { - fn metadata_lookup(&mut self) -> &mut ::MetadataLookup { +*/ +/* +impl WithMetadataLookup for WasmSqliteConnection { + fn metadata_lookup(&mut self) -> &mut ::MetadataLookup { &mut self.metadata_lookup } } + */ #[cfg(feature = "r2d2")] impl crate::r2d2::R2D2Connection for crate::sqlite::SqliteConnection { @@ -230,7 +159,7 @@ impl crate::r2d2::R2D2Connection for crate::sqlite::SqliteConnection { AnsiTransactionManager::is_broken_transaction_manager(self) } } - + /* impl MultiConnectionHelper for SqliteConnection { fn to_any<'a>( lookup: &mut ::MetadataLookup, @@ -244,8 +173,9 @@ impl MultiConnectionHelper for SqliteConnection { lookup.downcast_mut() } } +*/ -impl SqliteConnection { +impl WasmSqliteConnection { /// Run a transaction with `BEGIN IMMEDIATE` /// /// This method will return an error if a transaction is already open. @@ -267,12 +197,12 @@ impl SqliteConnection { /// }) /// # } /// ``` - pub fn immediate_transaction(&mut self, f: F) -> Result + pub async fn immediate_transaction(&mut self, f: F) -> Result where F: FnOnce(&mut Self) -> Result, E: From, { - self.transaction_sql(f, "BEGIN IMMEDIATE") + self.transaction_sql(f, "BEGIN IMMEDIATE").await } /// Run a transaction with `BEGIN EXCLUSIVE` @@ -296,67 +226,58 @@ impl SqliteConnection { /// }) /// # } /// ``` - pub fn exclusive_transaction(&mut self, f: F) -> Result + pub async fn exclusive_transaction(&mut self, f: F) -> Result where F: FnOnce(&mut Self) -> Result, E: From, { - self.transaction_sql(f, "BEGIN EXCLUSIVE") + self.transaction_sql(f, "BEGIN EXCLUSIVE").await } - fn transaction_sql(&mut self, f: F, sql: &str) -> Result + async fn transaction_sql(&mut self, f: F, sql: &str) -> Result where F: FnOnce(&mut Self) -> Result, E: From, { - AnsiTransactionManager::begin_transaction_sql(&mut *self, sql)?; + AnsiTransactionManager::begin_transaction_sql(&mut *self, sql).await?; match f(&mut *self) { Ok(value) => { - AnsiTransactionManager::commit_transaction(&mut *self)?; + AnsiTransactionManager::commit_transaction(&mut *self).await?; Ok(value) } Err(e) => { - AnsiTransactionManager::rollback_transaction(&mut *self)?; + AnsiTransactionManager::rollback_transaction(&mut *self).await?; Err(e) } } } - +/* fn prepared_query<'conn, 'query, T>( &'conn mut self, source: T, ) -> QueryResult> where - T: QueryFragment + QueryId + 'query, + T: QueryFragment + QueryId + 'query, { - self.instrumentation - .on_connection_event(InstrumentationEvent::StartQuery { - query: &crate::debug_query(&source), - }); let raw_connection = &self.raw_connection; let cache = &mut self.statement_cache; - let statement = match cache.cached_statement( + let statement = match cache.cached_prepared_statement( &source, - &Sqlite, + &WasmSqlite, &[], |sql, is_cached| Statement::prepare(raw_connection, sql, is_cached), &mut self.instrumentation, ) { Ok(statement) => statement, Err(e) => { - self.instrumentation - .on_connection_event(InstrumentationEvent::FinishQuery { - query: &crate::debug_query(&source), - error: Some(&e), - }); - return Err(e); } }; StatementUse::bind(statement, source, &mut self.instrumentation) } - + */ + /* #[doc(hidden)] pub fn register_sql_function( &mut self, @@ -366,9 +287,9 @@ impl SqliteConnection { ) -> QueryResult<()> where F: FnMut(Args) -> Ret + std::panic::UnwindSafe + Send + 'static, - Args: FromSqlRow + StaticallySizedRow, - Ret: ToSql, - Sqlite: HasSqlType, + Args: FromSqlRow + StaticallySizedRow, + Ret: ToSql, + WasmSqlite: HasSqlType, { functions::register( &self.raw_connection, @@ -377,7 +298,7 @@ impl SqliteConnection { move |_, args| f(args), ) } - + #[doc(hidden)] pub fn register_noarg_sql_function( &self, @@ -387,8 +308,8 @@ impl SqliteConnection { ) -> QueryResult<()> where F: FnMut() -> Ret + std::panic::UnwindSafe + Send + 'static, - Ret: ToSql, - Sqlite: HasSqlType, + Ret: ToSql, + WasmSqlite: HasSqlType, { functions::register_noargs(&self.raw_connection, fn_name, deterministic, f) } @@ -406,7 +327,7 @@ impl SqliteConnection { { functions::register_aggregate::<_, _, _, _, A>(&self.raw_connection, fn_name) } - + /// Register a collation function. /// /// `collation` must always return the same answer given the same inputs. @@ -449,7 +370,6 @@ impl SqliteConnection { self.raw_connection .register_collation_function(collation_name, collation) } - /// Serialize the current SQLite database into a byte buffer. /// /// The serialized data is identical to the data that would be written to disk if the database @@ -461,7 +381,7 @@ impl SqliteConnection { pub fn serialize_database_to_buffer(&mut self) -> SerializedDatabase { self.raw_connection.serialize() } - + /// Deserialize an SQLite database from a byte buffer. /// /// This function takes a byte slice and attempts to deserialize it into a SQLite database. @@ -501,45 +421,49 @@ impl SqliteConnection { pub fn deserialize_readonly_database_from_buffer(&mut self, data: &[u8]) -> QueryResult<()> { self.raw_connection.deserialize(data) } - - fn register_diesel_sql_functions(&self) -> QueryResult<()> { - use crate::sql_types::{Integer, Text}; + */ + /* + async fn register_diesel_sql_functions(&self) -> QueryResult<()> { + use diesel::sql_types::{Integer, Text}; functions::register::( &self.raw_connection, "diesel_manage_updated_at", false, - |conn, table_name: String| { + |conn, table_name: String| async { conn.exec(&format!( include_str!("diesel_manage_updated_at.sql"), table_name = table_name )) + .await .expect("Failed to create trigger"); 0 // have to return *something* - }, + }.boxed(), ) } + */ - fn establish_inner(database_url: &str) -> Result { - use crate::result::ConnectionError::CouldntSetupConfiguration; - let raw_connection = RawConnection::establish(database_url)?; + async fn establish_inner(database_url: &str) -> Result { + use diesel::result::ConnectionError::CouldntSetupConfiguration; + let raw_connection = RawConnection::establish(database_url).await.unwrap(); let conn = Self { - statement_cache: StatementCache::new(), + statement_cache: StmtCache::new(), raw_connection, transaction_state: AnsiTransactionManager::default(), metadata_lookup: (), instrumentation: None, }; + /* conn.register_diesel_sql_functions() - .map_err(CouldntSetupConfiguration)?; + .map_err(CouldntSetupConfiguration).await?; + */ Ok(conn) } } -*/ /* fn error_message(err_code: i32) -> &'static str { - let sqlite3 = crate::get_sqlite_unchecked(); + let sqlite3 = diesel::get_sqlite_unchecked(); sqlite3.code_to_str(err_code) } */ diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs index cd971af49..c7874c9f6 100644 --- a/diesel-wasm-sqlite/src/connection/raw.rs +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -12,9 +12,8 @@ use crate::{ sqlite_types::{SqliteFlags, SqliteOpenFlags}, WasmSqlite, WasmSqliteError, }; -use diesel::result::*; -use diesel::serialize::ToSql; -use diesel::sql_types::HasSqlType; +use diesel::{result::*, serialize::ToSql, sql_types::HasSqlType}; +use futures::future::BoxFuture; use wasm_bindgen::{closure::Closure, JsValue}; /* /// For use in FFI function, which cannot unwind. @@ -73,15 +72,17 @@ impl RawConnection { sqlite3.changes(&self.internal_connection) } - pub(super) fn register_sql_function( + pub(super) fn register_sql_function( &self, fn_name: &str, - num_args: i32, + num_args: usize, deterministic: bool, f: F, ) -> QueryResult<()> where - F: FnMut(JsValue, JsValue) + 'static, + F: FnMut(JsValue, Vec) -> JsValue + 'static, + Ret: ToSql, + WasmSqlite: HasSqlType, { let sqlite3 = crate::get_sqlite_unchecked(); let flags = Self::get_flags(deterministic); @@ -91,8 +92,11 @@ impl RawConnection { .create_function( &self.internal_connection, fn_name, - num_args, + num_args + .try_into() + .expect("usize to i32 panicked in register_sql_function"), flags, + 0, Some(&cb), None, None, @@ -108,6 +112,38 @@ impl RawConnection { } flags.bits() as i32 } + + /* possible to implement this, but would need to fill in the missing wa-sqlite functions + pub(super) fn serialize(&mut self) -> SerializedDatabase { + unsafe { + let mut size: ffi::sqlite3_int64 = 0; + let data_ptr = ffi::sqlite3_serialize( + self.internal_connection.as_ptr(), + std::ptr::null(), + &mut size as *mut _, + 0, + ); + SerializedDatabase::new(data_ptr, size as usize) + } + } + + pub(super) fn deserialize(&mut self, data: &[u8]) -> QueryResult<()> { + // the cast for `ffi::SQLITE_DESERIALIZE_READONLY` is required for old libsqlite3-sys versions + #[allow(clippy::unnecessary_cast)] + unsafe { + let result = ffi::sqlite3_deserialize( + self.internal_connection.as_ptr(), + std::ptr::null(), + data.as_ptr() as *mut u8, + data.len() as i64, + data.len() as i64, + ffi::SQLITE_DESERIALIZE_READONLY as u32, + ); + + ensure_sqlite_ok(result, self.internal_connection.as_ptr()) + } + } + */ } /* TODO: AsyncDrop diff --git a/diesel-wasm-sqlite/src/connection/serialized_database.rs b/diesel-wasm-sqlite/src/connection/serialized_database.rs index 28a98a286..e302a097c 100644 --- a/diesel-wasm-sqlite/src/connection/serialized_database.rs +++ b/diesel-wasm-sqlite/src/connection/serialized_database.rs @@ -1,13 +1,10 @@ -#![allow(unsafe_code)] -extern crate libsqlite3_sys as ffi; - use std::ops::Deref; /// `SerializedDatabase` is a wrapper for a serialized database that is dynamically allocated by calling `sqlite3_serialize`. /// This RAII wrapper is necessary to deallocate the memory when it goes out of scope with `sqlite3_free`. #[derive(Debug)] pub struct SerializedDatabase { - data: *mut u8, + data: JsValue, len: usize, } diff --git a/diesel-wasm-sqlite/src/connection/stmt.rs b/diesel-wasm-sqlite/src/connection/stmt.rs index 997994d95..a7adc6320 100644 --- a/diesel-wasm-sqlite/src/connection/stmt.rs +++ b/diesel-wasm-sqlite/src/connection/stmt.rs @@ -16,11 +16,13 @@ use diesel::{ result::{Error::DatabaseError, *}, }; use std::cell::OnceCell; +use std::sync::Arc; use wasm_bindgen::JsValue; pub(super) struct Statement { inner_statement: JsValue, + // drop_signal: Option>>, } impl Statement { @@ -49,9 +51,28 @@ impl Statement { ) .await .unwrap(); + /* + let (tx, rx) = tokio::sync::oneshot::channel::>(); + // We don't have `AsyncDrop` in rust yet. + // instead, we `send` a signal on Drop for the destructor to run in an + // asynchronously-spawned task. + + tokio::spawn(async move { + match rx.await { + Ok(this) => { + this.reset().await; + this.clear_bindings(); + } + Err(_) => { + log::error!("Statement never dropped"); + } + } + }); + */ Ok(Statement { inner_statement: stmt, + // drop_signal: Some(tx), }) } @@ -214,7 +235,7 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { // we don't track binds to free like sqlite3 C bindings // The assumption is that wa-sqlite, being WASM run in web browser that // lies in the middle of rust -> sqlite, takes care of this for us. - // if we run into memory issues, especailly memory leaks + // if we run into memory issues, especially memory leaks // this should be the first place to pay attention to. // // The bindings shuold be collected/freed with JS once `clear_bindings` is @@ -238,20 +259,33 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { } */ } + + // FIXME: [`AsyncDrop`](https://github.com/rust-lang/rust/issues/126482) is a missing feature in rust. + // Until then we need to manually reset the statement object. + pub async fn reset(&mut self) { + self.statement.reset().await; + self.statement.clear_bindings() + } } -// TODO: AsyncDrop +// Eventually replace with `AsyncDrop`: https://github.com/rust-lang/rust/issues/126482 impl<'stmt, 'query> Drop for BoundStatement<'stmt, 'query> { fn drop(&mut self) { + /* + let sender = self + .statement + .drop_signal + .take() + .expect("Drop may only be ran once"); + */ + // sender.send(Arc::new(*(&mut self.statement)); + /* // First reset the statement, otherwise the bind calls // below will fail self.statement.reset(); self.statement.clear_bindings(); - - if let Some(query) = &mut self.query { - std::mem::drop(query); - self.query = None; - } + */ + self.query.take(); } } diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index 6d011e95c..6b2355dea 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -203,8 +203,9 @@ extern "C" { functionName: &str, n_arg: i32, textRep: i32, - x_func: Option<&Closure>, - x_step: Option<&Closure>, + pApp: i32, //ignored + x_func: Option<&Closure) -> JsValue>>, + x_step: Option<&Closure) -> JsValue>>, x_final: Option<&Closure>, ) -> Result<(), JsValue>; } diff --git a/diesel-wasm-sqlite/src/lib.rs b/diesel-wasm-sqlite/src/lib.rs old mode 100644 new mode 100755 diff --git a/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js index 2a671e661..9e68f87cd 100644 --- a/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js +++ b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js @@ -2972,14 +2972,23 @@ class SQLite { } } - create_function(database, functionName, nArg, textRep, xFunc, xStep, xFinal) { + create_function( + database, + functionName, + nArg, + textRep, + pApp, + xFunc, + xStep, + xFinal, + ) { try { sqlite.create_function( database, functionName, nArg, textRep, - 0, + pApp, // pApp is ignored xFunc, xStep, xFinal, @@ -2989,6 +2998,12 @@ class SQLite { console.log("create function err"); } } + + /* + serialize(database, zSchema, size, flags) { + return this.module._sqlite3_serialize(database, zSchema, size, flags); + } + */ } export { SQLite }; From bd73a18326194b895f99cd3ed3e7e47aaf06e96d Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Mon, 12 Aug 2024 13:49:34 -0400 Subject: [PATCH 22/28] test --- diesel-wasm-sqlite/package.js | 7 ++- diesel-wasm-sqlite/src/connection/mod.rs | 3 +- diesel-wasm-sqlite/src/connection/raw.rs | 7 ++- diesel-wasm-sqlite/src/connection/row.rs | 2 + diesel-wasm-sqlite/src/connection/stmt.rs | 3 +- .../src/wa-sqlite-diesel-bundle.js | 7 ++- diesel-wasm-sqlite/tests/web.rs | 57 +++++++++++++++---- 7 files changed, 67 insertions(+), 19 deletions(-) diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index 7c4e4b335..5b1084e64 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -203,9 +203,12 @@ export class SQLite { async exec(db, query) { try { - return await this.sqlite3.exec(db, query); - } catch { + return await this.sqlite3.exec(db, query, (row, columns) => { + console.log(row); + }); + } catch (error) { console.log("exec err"); + throw error; } } diff --git a/diesel-wasm-sqlite/src/connection/mod.rs b/diesel-wasm-sqlite/src/connection/mod.rs index 0fb898c86..868d5a46f 100644 --- a/diesel-wasm-sqlite/src/connection/mod.rs +++ b/diesel-wasm-sqlite/src/connection/mod.rs @@ -37,7 +37,7 @@ pub struct WasmSqliteConnection { // otherwise we will get errors about open statements before closing the // connection itself statement_cache: StmtCache, - raw_connection: RawConnection, + pub raw_connection: RawConnection, transaction_state: AnsiTransactionManager, // this exists for the sole purpose of implementing `WithMetadataLookup` trait // and avoiding static mut which will be deprecated in 2024 edition @@ -78,6 +78,7 @@ impl AsyncConnection for WasmSqliteConnection { type Row<'conn, 'query> = SqliteRow<'conn, 'query>; async fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { + //TODO: Change to `establish_inner` Ok(WasmSqliteConnection { statement_cache: StmtCache::new(), raw_connection: raw::RawConnection::establish(database_url).await.unwrap(), diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs index c7874c9f6..ba67dfa4f 100644 --- a/diesel-wasm-sqlite/src/connection/raw.rs +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -32,7 +32,7 @@ macro_rules! assert_fail { #[allow(missing_copy_implementations)] #[derive(Clone, Debug)] -pub(super) struct RawConnection { +pub struct RawConnection { pub(super) internal_connection: JsValue, } @@ -57,7 +57,7 @@ impl RawConnection { }) } - pub(super) async fn exec(&self, query: &str) -> QueryResult<()> { + pub async fn exec(&self, query: &str) -> QueryResult<()> { let sqlite3 = crate::get_sqlite().await; let result = sqlite3 .exec(&self.internal_connection, query) @@ -198,7 +198,7 @@ impl From for SqliteCallbackError { } } */ - +/* #[cfg(test)] mod tests { use super::*; @@ -219,3 +219,4 @@ mod tests { }); } } +*/ diff --git a/diesel-wasm-sqlite/src/connection/row.rs b/diesel-wasm-sqlite/src/connection/row.rs index 3d9f1d94f..41c2c132d 100644 --- a/diesel-wasm-sqlite/src/connection/row.rs +++ b/diesel-wasm-sqlite/src/connection/row.rs @@ -202,6 +202,7 @@ impl<'stmt, 'query> Field<'stmt, WasmSqlite> for SqliteField<'stmt, 'query> { } } +/* #[cfg(test)] mod tests { use super::*; @@ -408,3 +409,4 @@ mod tests { handle.join().unwrap(); } } +*/ diff --git a/diesel-wasm-sqlite/src/connection/stmt.rs b/diesel-wasm-sqlite/src/connection/stmt.rs index a7adc6320..65bc87701 100644 --- a/diesel-wasm-sqlite/src/connection/stmt.rs +++ b/diesel-wasm-sqlite/src/connection/stmt.rs @@ -395,7 +395,7 @@ impl<'stmt, 'query> StatementUse<'stmt, 'query> { Some(sqlite3.column(&self.statement.statement.inner_statement, idx)) } } - +/* #[cfg(test)] mod tests { use crate::prelude::*; @@ -421,3 +421,4 @@ mod tests { } } } +*/ diff --git a/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js index 9e68f87cd..718886101 100644 --- a/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js +++ b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js @@ -2902,9 +2902,12 @@ class SQLite { async exec(db, query) { try { - return await this.sqlite3.exec(db, query); - } catch { + return await this.sqlite3.exec(db, query, (row, columns) => { + console.log(row); + }); + } catch (error) { console.log("exec err"); + throw error; } } diff --git a/diesel-wasm-sqlite/tests/web.rs b/diesel-wasm-sqlite/tests/web.rs index dcd07b536..622b3ba40 100755 --- a/diesel-wasm-sqlite/tests/web.rs +++ b/diesel-wasm-sqlite/tests/web.rs @@ -7,17 +7,54 @@ use web_sys::console; wasm_bindgen_test_configure!(run_in_dedicated_worker); #[wasm_bindgen_test] -async fn test_establish() { +async fn test_establish_and_exec() { let rng: u16 = rand::random(); - /* let url = format!( - "{}/wasmtest-{}.db3", - std::env::temp_dir().to_str().unwrap(), - rng - ); - */ - let mut result = WasmSqliteConnection::establish("test").await; + let result = WasmSqliteConnection::establish(&format!("test-{}", rng)).await; let mut conn = result.unwrap(); console::log_1(&"CONNECTED".into()); - // assert 1 == 2 is here b/c can't get --nocapture to work yet - assert_eq!(1, 2); + + let raw = conn.raw_connection; + + console::log_1(&"CREATE".into()); + raw.exec( + " + CREATE TABLE books ( + id INTEGER PRIMARY KEY, + title TEXT NOT NULL, + author TEXT NOT NULL, + published_year INTEGER, + genre TEXT + );", + ) + .await; + + console::log_1(&"INSERT".into()); + raw.exec( + " + INSERT INTO books (title, author, published_year, genre) VALUES + ('To Kill a Mockingbird', 'Harper Lee', 1960, 'Fiction'), + ('1984', 'George Orwell', 1949, 'Dystopian'), + ('The Great Gatsby', 'F. Scott Fitzgerald', 1925, 'Classics'), + ('Pride and Prejudice', 'Jane Austen', 1813, 'Romance'); + ", + ) + .await; + + console::log_1(&"SELECT ALL".into()); + raw.exec("SELECT * FROM books").await; + + console::log_1(&"SELECT title, author FROM books WHERE published_year > 1950;".into()); + raw.exec( + " + + SELECT title, published_year FROM books WHERE author = 'George Orwell'; + ", + ) + .await; + + console::log_1( + &"SELECT title, published_year FROM books WHERE author = 'George Orwell';".into(), + ); + raw.exec("SELECT title, author FROM books WHERE published_year > 1950;".into()) + .await; } From 71fdcff1212bc878362d8fb7f5d25c1587504b28 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Mon, 12 Aug 2024 17:37:33 -0400 Subject: [PATCH 23/28] async drop for RawConnection --- diesel-wasm-sqlite/src/connection/raw.rs | 47 ++++++++++++++---------- diesel-wasm-sqlite/tests/web.rs | 2 +- 2 files changed, 28 insertions(+), 21 deletions(-) diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs index ba67dfa4f..2d15c729f 100644 --- a/diesel-wasm-sqlite/src/connection/raw.rs +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -14,7 +14,9 @@ use crate::{ }; use diesel::{result::*, serialize::ToSql, sql_types::HasSqlType}; use futures::future::BoxFuture; +use tokio::sync::oneshot; use wasm_bindgen::{closure::Closure, JsValue}; + /* /// For use in FFI function, which cannot unwind. /// Print the message, ask to open an issue at Github and [`abort`](std::process::abort). @@ -31,9 +33,10 @@ macro_rules! assert_fail { */ #[allow(missing_copy_implementations)] -#[derive(Clone, Debug)] -pub struct RawConnection { +#[derive(Debug)] +pub(super) struct RawConnection { pub(super) internal_connection: JsValue, + drop_signal: Option>, } impl RawConnection { @@ -48,16 +51,32 @@ impl RawConnection { | SqliteOpenFlags::SQLITE_OPEN_CREATE | SqliteOpenFlags::SQLITE_OPEN_URI; + let (tx, rx) = oneshot::channel::(); + wasm_bindgen_futures::spawn_local(async move { + let conn = rx.await; + + let sqlite3 = crate::get_sqlite_unchecked(); + + match sqlite3.close(&conn.unwrap()).await { + Ok(_) => log::debug!("db closed"), + Err(e) => { + log::error!("error during db close"); + web_sys::console::log_1(&e); + } + } + }); + Ok(RawConnection { internal_connection: sqlite3 .open_v2(&database_url, Some(flags.bits() as i32)) .await .map_err(WasmSqliteError::from) .map_err(ConnectionError::from)?, + drop_signal: Some(tx), }) } - pub async fn exec(&self, query: &str) -> QueryResult<()> { + pub(super) async fn exec(&self, query: &str) -> QueryResult<()> { let sqlite3 = crate::get_sqlite().await; let result = sqlite3 .exec(&self.internal_connection, query) @@ -146,27 +165,15 @@ impl RawConnection { */ } -/* TODO: AsyncDrop impl Drop for RawConnection { fn drop(&mut self) { - use std::thread::panicking; - - let sqlite3 = crate::get_sqlite_unchecked(); - - let close_result = sqlite3.close(self.internal_connection).unwrap(); - - if close_result != ffi::SQLITE_OK { - let error_message = super::error_message(close_result); - if panicking() { - write!(stderr(), "Error closing SQLite connection: {error_message}") - .expect("Error writing to `stderr`"); - } else { - panic!("Error closing SQLite connection: {}", error_message); - } - } + let sender = self + .drop_signal + .take() + .expect("Drop is only unwrapped once"); + sender.send(self.internal_connection.clone()); } } -*/ /* enum SqliteCallbackError { diff --git a/diesel-wasm-sqlite/tests/web.rs b/diesel-wasm-sqlite/tests/web.rs index 622b3ba40..cec5502c0 100755 --- a/diesel-wasm-sqlite/tests/web.rs +++ b/diesel-wasm-sqlite/tests/web.rs @@ -9,7 +9,7 @@ wasm_bindgen_test_configure!(run_in_dedicated_worker); #[wasm_bindgen_test] async fn test_establish_and_exec() { let rng: u16 = rand::random(); - let result = WasmSqliteConnection::establish(&format!("test-{}", rng)).await; + let result = WasmSqliteConnection::establish("test-15873").await; let mut conn = result.unwrap(); console::log_1(&"CONNECTED".into()); From 746aeec447372840cc1ecfde71fb527d4cadf30e Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Mon, 12 Aug 2024 17:46:57 -0400 Subject: [PATCH 24/28] Drop for Statement --- diesel-wasm-sqlite/src/connection/raw.rs | 57 ++++++----------------- diesel-wasm-sqlite/src/connection/stmt.rs | 39 +++++++--------- diesel-wasm-sqlite/tests/web.rs | 7 +-- 3 files changed, 36 insertions(+), 67 deletions(-) diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs index 2d15c729f..093ceb413 100644 --- a/diesel-wasm-sqlite/src/connection/raw.rs +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -52,16 +52,21 @@ impl RawConnection { | SqliteOpenFlags::SQLITE_OPEN_URI; let (tx, rx) = oneshot::channel::(); + // TODO: can make this into function/macro wasm_bindgen_futures::spawn_local(async move { - let conn = rx.await; - - let sqlite3 = crate::get_sqlite_unchecked(); - - match sqlite3.close(&conn.unwrap()).await { - Ok(_) => log::debug!("db closed"), - Err(e) => { - log::error!("error during db close"); - web_sys::console::log_1(&e); + match rx.await { + Ok(conn) => { + let sqlite3 = crate::get_sqlite_unchecked(); + match sqlite3.close(&conn).await { + Ok(_) => log::debug!("db closed"), + Err(e) => { + log::error!("error during db close"); + web_sys::console::log_1(&e); + } + } + } + Err(_) => { + log::error!("RawConnection never dropped."); } } }); @@ -171,41 +176,10 @@ impl Drop for RawConnection { .drop_signal .take() .expect("Drop is only unwrapped once"); - sender.send(self.internal_connection.clone()); - } -} - -/* -enum SqliteCallbackError { - Abort(&'static str), - DieselError(crate::result::Error), - Panic(String), -} - -impl SqliteCallbackError { - fn emit(&self, ctx: *mut ffi::sqlite3_context) { - let s; - let msg = match self { - SqliteCallbackError::Abort(msg) => *msg, - SqliteCallbackError::DieselError(e) => { - s = e.to_string(); - &s - } - SqliteCallbackError::Panic(msg) => msg, - }; - unsafe { - context_error_str(ctx, msg); - } + let _ = sender.send(self.internal_connection.clone()); } } -impl From for SqliteCallbackError { - fn from(e: crate::result::Error) -> Self { - Self::DieselError(e) - } -} -*/ -/* #[cfg(test)] mod tests { use super::*; @@ -226,4 +200,3 @@ mod tests { }); } } -*/ diff --git a/diesel-wasm-sqlite/src/connection/stmt.rs b/diesel-wasm-sqlite/src/connection/stmt.rs index 65bc87701..fbd118277 100644 --- a/diesel-wasm-sqlite/src/connection/stmt.rs +++ b/diesel-wasm-sqlite/src/connection/stmt.rs @@ -16,13 +16,12 @@ use diesel::{ result::{Error::DatabaseError, *}, }; use std::cell::OnceCell; -use std::sync::Arc; use wasm_bindgen::JsValue; pub(super) struct Statement { inner_statement: JsValue, - // drop_signal: Option>>, + drop_signal: Option>, } impl Statement { @@ -51,15 +50,20 @@ impl Statement { ) .await .unwrap(); - /* - let (tx, rx) = tokio::sync::oneshot::channel::>(); + + let (tx, rx) = tokio::sync::oneshot::channel::(); // We don't have `AsyncDrop` in rust yet. // instead, we `send` a signal on Drop for the destructor to run in an // asynchronously-spawned task. - tokio::spawn(async move { + wasm_bindgen_futures::spawn_local(async move { match rx.await { - Ok(this) => { + Ok(inner_statement) => { + let this = Statement { + inner_statement, + drop_signal: None, + }; + this.reset().await; this.clear_bindings(); } @@ -68,11 +72,10 @@ impl Statement { } } }); - */ Ok(Statement { inner_statement: stmt, - // drop_signal: Some(tx), + drop_signal: Some(tx), }) } @@ -271,20 +274,12 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { // Eventually replace with `AsyncDrop`: https://github.com/rust-lang/rust/issues/126482 impl<'stmt, 'query> Drop for BoundStatement<'stmt, 'query> { fn drop(&mut self) { - /* - let sender = self - .statement - .drop_signal - .take() - .expect("Drop may only be ran once"); - */ - // sender.send(Arc::new(*(&mut self.statement)); - /* - // First reset the statement, otherwise the bind calls - // below will fail - self.statement.reset(); - self.statement.clear_bindings(); - */ + let sender = self + .statement + .drop_signal + .take() + .expect("Drop may only be ran once"); + let _ = sender.send(self.statement.inner_statement.clone()); self.query.take(); } } diff --git a/diesel-wasm-sqlite/tests/web.rs b/diesel-wasm-sqlite/tests/web.rs index cec5502c0..b8a3a28a5 100755 --- a/diesel-wasm-sqlite/tests/web.rs +++ b/diesel-wasm-sqlite/tests/web.rs @@ -5,7 +5,7 @@ use diesel_wasm_sqlite::connection::{AsyncConnection, WasmSqliteConnection}; use wasm_bindgen_test::*; use web_sys::console; wasm_bindgen_test_configure!(run_in_dedicated_worker); - +/* #[wasm_bindgen_test] async fn test_establish_and_exec() { let rng: u16 = rand::random(); @@ -17,7 +17,7 @@ async fn test_establish_and_exec() { console::log_1(&"CREATE".into()); raw.exec( - " + " CREATE TABLE books ( id INTEGER PRIMARY KEY, title TEXT NOT NULL, @@ -30,7 +30,7 @@ async fn test_establish_and_exec() { console::log_1(&"INSERT".into()); raw.exec( - " + " INSERT INTO books (title, author, published_year, genre) VALUES ('To Kill a Mockingbird', 'Harper Lee', 1960, 'Fiction'), ('1984', 'George Orwell', 1949, 'Dystopian'), @@ -58,3 +58,4 @@ async fn test_establish_and_exec() { raw.exec("SELECT title, author FROM books WHERE published_year > 1950;".into()) .await; } +*/ From 35faacb4f2a012afc5e9041a17f67b96f8caa755 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Tue, 13 Aug 2024 11:19:57 -0400 Subject: [PATCH 25/28] prepared statements --- diesel-wasm-sqlite/Cargo.lock | 2 +- diesel-wasm-sqlite/src/connection/mod.rs | 51 ++++++++++++----------- diesel-wasm-sqlite/src/connection/raw.rs | 43 +++++++++++++++---- diesel-wasm-sqlite/src/connection/stmt.rs | 11 +++-- 4 files changed, 71 insertions(+), 36 deletions(-) diff --git a/diesel-wasm-sqlite/Cargo.lock b/diesel-wasm-sqlite/Cargo.lock index 8a32aca0c..aadc60362 100644 --- a/diesel-wasm-sqlite/Cargo.lock +++ b/diesel-wasm-sqlite/Cargo.lock @@ -142,7 +142,7 @@ dependencies = [ [[package]] name = "diesel-async" version = "0.5.0" -source = "git+https://github.com/insipx/diesel_async?branch=insipx/make-stmt-cache-public#2cd189fb9300dcaeb204d05526cc9b0e079096c2" +source = "git+https://github.com/insipx/diesel_async?branch=insipx/make-stmt-cache-public#86a24a38d9d841ef9e92022cd983bbd700286397" dependencies = [ "async-trait", "diesel", diff --git a/diesel-wasm-sqlite/src/connection/mod.rs b/diesel-wasm-sqlite/src/connection/mod.rs index 868d5a46f..db1a415e0 100644 --- a/diesel-wasm-sqlite/src/connection/mod.rs +++ b/diesel-wasm-sqlite/src/connection/mod.rs @@ -17,13 +17,11 @@ use self::raw::RawConnection; // use self::statement_iterator::*; use self::stmt::{Statement, StatementUse}; use crate::query_builder::*; -use diesel::connection::{DefaultLoadingMode, LoadConnection}; -use diesel::deserialize::{FromSqlRow, StaticallySizedRow}; -use diesel::expression::QueryMetadata; -use diesel::result::*; -use diesel::serialize::ToSql; -use diesel::sql_types::HasSqlType; +use diesel::{connection::{statement_cache::StatementCacheKey, DefaultLoadingMode, LoadConnection}, deserialize::{FromSqlRow, StaticallySizedRow}, expression::QueryMetadata, query_builder::QueryBuilder as _, result::*, serialize::ToSql, sql_types::HasSqlType}; +use futures::future::Either; use futures::{FutureExt, TryFutureExt}; +use std::sync::{Arc, Mutex}; + use diesel::{connection::{ConnectionSealed, Instrumentation, WithMetadataLookup}, query_builder::{AsQuery, QueryFragment, QueryId}, sql_types::TypeMetadata, QueryResult}; pub use diesel_async::{AnsiTransactionManager, AsyncConnection, SimpleAsyncConnection, TransactionManager, stmt_cache::StmtCache}; @@ -42,7 +40,7 @@ pub struct WasmSqliteConnection { // this exists for the sole purpose of implementing `WithMetadataLookup` trait // and avoiding static mut which will be deprecated in 2024 edition metadata_lookup: (), - instrumentation: Option>, + instrumentation: Arc>>>, } @@ -84,7 +82,7 @@ impl AsyncConnection for WasmSqliteConnection { raw_connection: raw::RawConnection::establish(database_url).await.unwrap(), transaction_state: Default::default(), metadata_lookup: (), - instrumentation: None + instrumentation: Arc::new(Mutex::new(None)) }) } @@ -252,8 +250,8 @@ impl WasmSqliteConnection { } } } -/* - fn prepared_query<'conn, 'query, T>( + + async fn prepared_query<'conn, 'query, T>( &'conn mut self, source: T, ) -> QueryResult> @@ -262,22 +260,27 @@ impl WasmSqliteConnection { { let raw_connection = &self.raw_connection; let cache = &mut self.statement_cache; - let statement = match cache.cached_prepared_statement( - &source, - &WasmSqlite, + let maybe_type_id = T::query_id(); + let cache_key = StatementCacheKey::for_source(maybe_type_id, &source, &[], &WasmSqlite)?; + + + let is_safe_to_cache_prepared = source.is_safe_to_cache_prepared(&WasmSqlite)?; + let mut qb = SqliteQueryBuilder::new(); + let sql = source.to_sql(&mut qb, &WasmSqlite).map(|()| qb.finish())?; + + let statement = cache.cached_prepared_statement( + cache_key, + sql, + is_safe_to_cache_prepared, &[], - |sql, is_cached| Statement::prepare(raw_connection, sql, is_cached), - &mut self.instrumentation, - ) { - Ok(statement) => statement, - Err(e) => { - return Err(e); - } - }; + raw_connection.clone(), + &self.instrumentation, + ).await?.0; + - StatementUse::bind(statement, source, &mut self.instrumentation) + Ok(StatementUse::bind(statement, source, self.instrumentation.as_ref())?) + } - */ /* #[doc(hidden)] pub fn register_sql_function( @@ -452,7 +455,7 @@ impl WasmSqliteConnection { raw_connection, transaction_state: AnsiTransactionManager::default(), metadata_lookup: (), - instrumentation: None, + instrumentation: Arc::new(Mutex::new(None)), }; /* conn.register_diesel_sql_functions() diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs index 093ceb413..30bdff406 100644 --- a/diesel-wasm-sqlite/src/connection/raw.rs +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -10,13 +10,20 @@ // use crate::result::Error::DatabaseError; use crate::{ sqlite_types::{SqliteFlags, SqliteOpenFlags}, - WasmSqlite, WasmSqliteError, + SqliteType, WasmSqlite, WasmSqliteError, +}; +use diesel::{ + connection::statement_cache::PrepareForCache, + result::*, + serialize::ToSql, + sql_types::{HasSqlType, TypeMetadata}, }; -use diesel::{result::*, serialize::ToSql, sql_types::HasSqlType}; use futures::future::BoxFuture; use tokio::sync::oneshot; use wasm_bindgen::{closure::Closure, JsValue}; +use super::stmt::Statement; + /* /// For use in FFI function, which cannot unwind. /// Print the message, ask to open an issue at Github and [`abort`](std::process::abort). @@ -39,6 +46,15 @@ pub(super) struct RawConnection { drop_signal: Option>, } +impl Clone for RawConnection { + fn clone(&self) -> Self { + Self { + internal_connection: self.internal_connection.clone(), + drop_signal: None, + } + } +} + impl RawConnection { pub(super) async fn establish(database_url: &str) -> ConnectionResult { let sqlite3 = crate::get_sqlite().await; @@ -170,13 +186,26 @@ impl RawConnection { */ } +#[async_trait::async_trait(?Send)] +impl diesel_async::stmt_cache::PrepareCallback for RawConnection { + async fn prepare( + self, + sql: &str, + _metadata: &[SqliteType], + is_for_cache: PrepareForCache, + ) -> QueryResult<(Statement, Self)> { + let stmt = Statement::prepare(&self, sql, is_for_cache).await; + Ok((stmt?, self)) + } +} + impl Drop for RawConnection { fn drop(&mut self) { - let sender = self - .drop_signal - .take() - .expect("Drop is only unwrapped once"); - let _ = sender.send(self.internal_connection.clone()); + if let Some(s) = self.drop_signal.take() { + let _ = s.send(self.internal_connection.clone()); + } else { + log::warn!("RawConnection not dropped because drop_signal is empty"); + } } } diff --git a/diesel-wasm-sqlite/src/connection/stmt.rs b/diesel-wasm-sqlite/src/connection/stmt.rs index fbd118277..53fb5ba78 100644 --- a/diesel-wasm-sqlite/src/connection/stmt.rs +++ b/diesel-wasm-sqlite/src/connection/stmt.rs @@ -16,9 +16,12 @@ use diesel::{ result::{Error::DatabaseError, *}, }; use std::cell::OnceCell; +use std::sync::Mutex; use wasm_bindgen::JsValue; +// this is OK b/c web runs in one thread +unsafe impl Send for Statement {} pub(super) struct Statement { inner_statement: JsValue, drop_signal: Option>, @@ -52,10 +55,10 @@ impl Statement { .unwrap(); let (tx, rx) = tokio::sync::oneshot::channel::(); + // We don't have `AsyncDrop` in rust yet. // instead, we `send` a signal on Drop for the destructor to run in an // asynchronously-spawned task. - wasm_bindgen_futures::spawn_local(async move { match rx.await { Ok(inner_statement) => { @@ -183,7 +186,7 @@ struct BoundStatement<'stmt, 'query> { // generic type, we use NonNull to communicate // that this is a shared buffer query: Option + 'query>>, - instrumentation: &'stmt mut dyn Instrumentation, + instrumentation: &'stmt Mutex, has_error: bool, } @@ -191,7 +194,7 @@ impl<'stmt, 'query> BoundStatement<'stmt, 'query> { fn bind( statement: MaybeCached<'stmt, Statement>, query: T, - instrumentation: &'stmt mut dyn Instrumentation, + instrumentation: &'stmt Mutex, ) -> QueryResult> where T: QueryFragment + QueryId + 'query, @@ -294,7 +297,7 @@ impl<'stmt, 'query> StatementUse<'stmt, 'query> { pub(super) fn bind( statement: MaybeCached<'stmt, Statement>, query: T, - instrumentation: &'stmt mut dyn Instrumentation, + instrumentation: &'stmt Mutex, ) -> QueryResult> where T: QueryFragment + QueryId + 'query, From eae8461cb6da3b266507a1a69d2a5f45d8fa68bb Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Tue, 13 Aug 2024 11:50:49 -0400 Subject: [PATCH 26/28] diesel trigger --- diesel-wasm-sqlite/package.js | 42 ++++++++++++++++++- diesel-wasm-sqlite/src/connection/mod.rs | 2 +- .../src/wa-sqlite-diesel-bundle.js | 42 ++++++++++++++++++- 3 files changed, 81 insertions(+), 5 deletions(-) diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index 5b1084e64..3c317081c 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -269,7 +269,7 @@ export class SQLite { batch_execute(database, query) { try { - return sqlite3.exec(database, query); + return this.sqlite3.exec(database, query); console.log("Batch exec'ed"); } catch { console.log("exec err"); @@ -287,7 +287,7 @@ export class SQLite { xFinal, ) { try { - sqlite.create_function( + this.sqlite3.create_function( database, functionName, nArg, @@ -303,6 +303,44 @@ export class SQLite { } } + register_diesel_sql_functions(database) { + try { + this.sqlite3.create_function( + database, + "diesel_manage_updated_at", + 1, + WasmSQLiteLibrary.SQLITE_UTF8, + 0, + (context, values) => { + const table_name = this.sqlite3.value_text(values[0]); + + this.sqlite3.exec( + context, + `CREATE TRIGGER __diesel_manage_updated_at_${table_name} + AFTER UPDATE ON ${table_name} + FOR EACH ROW WHEN + old.updated_at IS NULL AND + new.updated_at IS NULL OR + old.updated_at == new.updated_at + BEGIN + UPDATE ${table_name} + SET updated_at = CURRENT_TIMESTAMP + WHERE ROWID = new.ROWID; + END`, + (row, columns) => { + console.log(`------------------------------------`); + console.log(`Created trigger for ${table_name}`); + console.log(row); + console.log(columns); + console.log(`------------------------------------`); + }, + ); + }, + ); + } catch (error) { + } + } + /* serialize(database, zSchema, size, flags) { return this.module._sqlite3_serialize(database, zSchema, size, flags); diff --git a/diesel-wasm-sqlite/src/connection/mod.rs b/diesel-wasm-sqlite/src/connection/mod.rs index db1a415e0..0ba358cf4 100644 --- a/diesel-wasm-sqlite/src/connection/mod.rs +++ b/diesel-wasm-sqlite/src/connection/mod.rs @@ -275,7 +275,7 @@ impl WasmSqliteConnection { &[], raw_connection.clone(), &self.instrumentation, - ).await?.0; + ).await?.0; // Cloned RawConnection is dropped here Ok(StatementUse::bind(statement, source, self.instrumentation.as_ref())?) diff --git a/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js index 718886101..2e16221b9 100644 --- a/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js +++ b/diesel-wasm-sqlite/src/wa-sqlite-diesel-bundle.js @@ -2968,7 +2968,7 @@ class SQLite { batch_execute(database, query) { try { - return sqlite3.exec(database, query); + return this.sqlite3.exec(database, query); console.log("Batch exec'ed"); } catch { console.log("exec err"); @@ -2986,7 +2986,7 @@ class SQLite { xFinal, ) { try { - sqlite.create_function( + this.sqlite3.create_function( database, functionName, nArg, @@ -3002,6 +3002,44 @@ class SQLite { } } + register_diesel_sql_functions(database) { + try { + this.sqlite3.create_function( + database, + "diesel_manage_updated_at", + 1, + SQLITE_UTF8, + 0, + (context, values) => { + const table_name = this.sqlite3.value_text(values[0]); + + this.sqlite3.exec( + context, + `CREATE TRIGGER __diesel_manage_updated_at_${table_name} + AFTER UPDATE ON ${table_name} + FOR EACH ROW WHEN + old.updated_at IS NULL AND + new.updated_at IS NULL OR + old.updated_at == new.updated_at + BEGIN + UPDATE ${table_name} + SET updated_at = CURRENT_TIMESTAMP + WHERE ROWID = new.ROWID; + END`, + (row, columns) => { + console.log(`------------------------------------`); + console.log(`Created trigger for ${table_name}`); + console.log(row); + console.log(columns); + console.log(`------------------------------------`); + }, + ); + }, + ); + } catch (error) { + } + } + /* serialize(database, zSchema, size, flags) { return this.module._sqlite3_serialize(database, zSchema, size, flags); From 0a3189cdcdc2e194825dfbad7f962d53a0a7f897 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Tue, 13 Aug 2024 16:22:02 -0400 Subject: [PATCH 27/28] cleanup a little --- diesel-wasm-sqlite/package.js | 7 +- diesel-wasm-sqlite/src/connection/mod.rs | 195 +---------------------- diesel-wasm-sqlite/src/connection/raw.rs | 32 +--- diesel-wasm-sqlite/src/ffi.rs | 7 +- 4 files changed, 19 insertions(+), 222 deletions(-) diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index 3c317081c..af3f1f4cf 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -302,7 +302,8 @@ export class SQLite { console.log("create function err"); } } - + //TODO: At some point need a way to register functions from rust + //but for just libxmtp this is fine. register_diesel_sql_functions(database) { try { this.sqlite3.create_function( @@ -314,7 +315,7 @@ export class SQLite { (context, values) => { const table_name = this.sqlite3.value_text(values[0]); - this.sqlite3.exec( + await this.sqlite3.exec( context, `CREATE TRIGGER __diesel_manage_updated_at_${table_name} AFTER UPDATE ON ${table_name} @@ -338,6 +339,8 @@ export class SQLite { }, ); } catch (error) { + console.log("error creating diesel trigger"); + throw error; } } diff --git a/diesel-wasm-sqlite/src/connection/mod.rs b/diesel-wasm-sqlite/src/connection/mod.rs index 0ba358cf4..fac2bbe8b 100644 --- a/diesel-wasm-sqlite/src/connection/mod.rs +++ b/diesel-wasm-sqlite/src/connection/mod.rs @@ -18,7 +18,6 @@ use self::raw::RawConnection; use self::stmt::{Statement, StatementUse}; use crate::query_builder::*; use diesel::{connection::{statement_cache::StatementCacheKey, DefaultLoadingMode, LoadConnection}, deserialize::{FromSqlRow, StaticallySizedRow}, expression::QueryMetadata, query_builder::QueryBuilder as _, result::*, serialize::ToSql, sql_types::HasSqlType}; -use futures::future::Either; use futures::{FutureExt, TryFutureExt}; use std::sync::{Arc, Mutex}; @@ -76,14 +75,7 @@ impl AsyncConnection for WasmSqliteConnection { type Row<'conn, 'query> = SqliteRow<'conn, 'query>; async fn establish(database_url: &str) -> diesel::prelude::ConnectionResult { - //TODO: Change to `establish_inner` - Ok(WasmSqliteConnection { - statement_cache: StmtCache::new(), - raw_connection: raw::RawConnection::establish(database_url).await.unwrap(), - transaction_state: Default::default(), - metadata_lookup: (), - instrumentation: Arc::new(Mutex::new(None)) - }) + WasmSqliteConnection::establish_inner(database_url).await } fn load<'conn, 'query, T>(&'conn mut self, _source: T) -> Self::LoadFuture<'conn, 'query> @@ -280,194 +272,21 @@ impl WasmSqliteConnection { Ok(StatementUse::bind(statement, source, self.instrumentation.as_ref())?) - } - /* - #[doc(hidden)] - pub fn register_sql_function( - &mut self, - fn_name: &str, - deterministic: bool, - mut f: F, - ) -> QueryResult<()> - where - F: FnMut(Args) -> Ret + std::panic::UnwindSafe + Send + 'static, - Args: FromSqlRow + StaticallySizedRow, - Ret: ToSql, - WasmSqlite: HasSqlType, - { - functions::register( - &self.raw_connection, - fn_name, - deterministic, - move |_, args| f(args), - ) } - #[doc(hidden)] - pub fn register_noarg_sql_function( - &self, - fn_name: &str, - deterministic: bool, - f: F, - ) -> QueryResult<()> - where - F: FnMut() -> Ret + std::panic::UnwindSafe + Send + 'static, - Ret: ToSql, - WasmSqlite: HasSqlType, - { - functions::register_noargs(&self.raw_connection, fn_name, deterministic, f) - } - - #[doc(hidden)] - pub fn register_aggregate_function( - &mut self, - fn_name: &str, - ) -> QueryResult<()> - where - A: SqliteAggregateFunction + 'static + Send + std::panic::UnwindSafe, - Args: FromSqlRow + StaticallySizedRow, - Ret: ToSql, - Sqlite: HasSqlType, - { - functions::register_aggregate::<_, _, _, _, A>(&self.raw_connection, fn_name) - } - - /// Register a collation function. - /// - /// `collation` must always return the same answer given the same inputs. - /// If `collation` panics and unwinds the stack, the process is aborted, since it is used - /// across a C FFI boundary, which cannot be unwound across and there is no way to - /// signal failures via the SQLite interface in this case.. - /// - /// If the name is already registered it will be overwritten. - /// - /// This method will return an error if registering the function fails, either due to an - /// out-of-memory situation or because a collation with that name already exists and is - /// currently being used in parallel by a query. - /// - /// The collation needs to be specified when creating a table: - /// `CREATE TABLE my_table ( str TEXT COLLATE MY_COLLATION )`, - /// where `MY_COLLATION` corresponds to name passed as `collation_name`. - /// - /// # Example - /// - /// ```rust - /// # include!("../../doctest_setup.rs"); - /// # - /// # fn main() { - /// # run_test().unwrap(); - /// # } - /// # - /// # fn run_test() -> QueryResult<()> { - /// # let mut conn = SqliteConnection::establish(":memory:").unwrap(); - /// // sqlite NOCASE only works for ASCII characters, - /// // this collation allows handling UTF-8 (barring locale differences) - /// conn.register_collation("RUSTNOCASE", |rhs, lhs| { - /// rhs.to_lowercase().cmp(&lhs.to_lowercase()) - /// }) - /// # } - /// ``` - pub fn register_collation(&mut self, collation_name: &str, collation: F) -> QueryResult<()> - where - F: Fn(&str, &str) -> std::cmp::Ordering + Send + 'static + std::panic::UnwindSafe, - { - self.raw_connection - .register_collation_function(collation_name, collation) - } - /// Serialize the current SQLite database into a byte buffer. - /// - /// The serialized data is identical to the data that would be written to disk if the database - /// was saved in a file. - /// - /// # Returns - /// - /// This function returns a byte slice representing the serialized database. - pub fn serialize_database_to_buffer(&mut self) -> SerializedDatabase { - self.raw_connection.serialize() - } - - /// Deserialize an SQLite database from a byte buffer. - /// - /// This function takes a byte slice and attempts to deserialize it into a SQLite database. - /// If successful, the database is loaded into the connection. If the deserialization fails, - /// an error is returned. - /// - /// The database is opened in READONLY mode. - /// - /// # Example - /// - /// ```no_run - /// # use diesel::sqlite::SerializedDatabase; - /// # use diesel::sqlite::SqliteConnection; - /// # use diesel::result::QueryResult; - /// # use diesel::sql_query; - /// # use diesel::Connection; - /// # use diesel::RunQueryDsl; - /// # fn main() { - /// let connection = &mut SqliteConnection::establish(":memory:").unwrap(); - /// - /// sql_query("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)") - /// .execute(connection).unwrap(); - /// sql_query("INSERT INTO users (name, email) VALUES ('John Doe', 'john.doe@example.com'), ('Jane Doe', 'jane.doe@example.com')") - /// .execute(connection).unwrap(); - /// - /// // Serialize the database to a byte vector - /// let serialized_db: SerializedDatabase = connection.serialize_database_to_buffer(); - /// - /// // Create a new in-memory SQLite database - /// let connection = &mut SqliteConnection::establish(":memory:").unwrap(); - /// - /// // Deserialize the byte vector into the new database - /// connection.deserialize_readonly_database_from_buffer(serialized_db.as_slice()).unwrap(); - /// # - /// # } - /// ``` - pub fn deserialize_readonly_database_from_buffer(&mut self, data: &[u8]) -> QueryResult<()> { - self.raw_connection.deserialize(data) - } - */ - /* - async fn register_diesel_sql_functions(&self) -> QueryResult<()> { - use diesel::sql_types::{Integer, Text}; - - functions::register::( - &self.raw_connection, - "diesel_manage_updated_at", - false, - |conn, table_name: String| async { - conn.exec(&format!( - include_str!("diesel_manage_updated_at.sql"), - table_name = table_name - )) - .await - .expect("Failed to create trigger"); - 0 // have to return *something* - }.boxed(), - ) - } - */ - async fn establish_inner(database_url: &str) -> Result { use diesel::result::ConnectionError::CouldntSetupConfiguration; let raw_connection = RawConnection::establish(database_url).await.unwrap(); - let conn = Self { + let sqlite3 = crate::get_sqlite().await; + + sqlite3.register_diesel_sql_functions(&raw_connection.internal_connection).map_err(WasmSqliteError::from)?; + + Ok(Self { statement_cache: StmtCache::new(), raw_connection, transaction_state: AnsiTransactionManager::default(), metadata_lookup: (), instrumentation: Arc::new(Mutex::new(None)), - }; - /* - conn.register_diesel_sql_functions() - .map_err(CouldntSetupConfiguration).await?; - */ - Ok(conn) + }) } } - -/* -fn error_message(err_code: i32) -> &'static str { - let sqlite3 = diesel::get_sqlite_unchecked(); - sqlite3.code_to_str(err_code) -} -*/ diff --git a/diesel-wasm-sqlite/src/connection/raw.rs b/diesel-wasm-sqlite/src/connection/raw.rs index 30bdff406..dd11abf25 100644 --- a/diesel-wasm-sqlite/src/connection/raw.rs +++ b/diesel-wasm-sqlite/src/connection/raw.rs @@ -1,44 +1,16 @@ -#![allow(unsafe_code)] // ffi calls - -// use std::io::{stderr, Write}; - -// use super::functions::{build_sql_function_args, process_sql_function_result}; -// use super::serialized_database::SerializedDatabase; -// use super::stmt::ensure_sqlite_ok; -// use super::{Sqlite, SqliteAggregateFunction}; -// use crate::deserialize::FromSqlRow; -// use crate::result::Error::DatabaseError; use crate::{ sqlite_types::{SqliteFlags, SqliteOpenFlags}, SqliteType, WasmSqlite, WasmSqliteError, }; use diesel::{ - connection::statement_cache::PrepareForCache, - result::*, - serialize::ToSql, - sql_types::{HasSqlType, TypeMetadata}, + connection::statement_cache::PrepareForCache, result::*, serialize::ToSql, + sql_types::HasSqlType, }; -use futures::future::BoxFuture; use tokio::sync::oneshot; use wasm_bindgen::{closure::Closure, JsValue}; use super::stmt::Statement; -/* -/// For use in FFI function, which cannot unwind. -/// Print the message, ask to open an issue at Github and [`abort`](std::process::abort). -macro_rules! assert_fail { - ($fmt:expr $(,$args:tt)*) => { - eprint!(concat!( - $fmt, - "If you see this message, please open an issue at https://github.com/diesel-rs/diesel/issues/new.\n", - "Source location: {}:{}\n", - ), $($args,)* file!(), line!()); - std::process::abort() - }; -} -*/ - #[allow(missing_copy_implementations)] #[derive(Debug)] pub(super) struct RawConnection { diff --git a/diesel-wasm-sqlite/src/ffi.rs b/diesel-wasm-sqlite/src/ffi.rs index 6b2355dea..9b11e0c95 100644 --- a/diesel-wasm-sqlite/src/ffi.rs +++ b/diesel-wasm-sqlite/src/ffi.rs @@ -21,8 +21,8 @@ pub mod consts { // Constants #[wasm_bindgen(module = "/src/wa-sqlite-diesel-bundle.js")] extern "C" { - pub static SqliteDone: i32; - pub static SqliteRow: i32; + pub static SQLITE_DONE: i32; + pub static SQLITE_ROW: i32; // Fundamental datatypes. // https://www.sqlite.org/c3ref/c_blob.html @@ -208,6 +208,9 @@ extern "C" { x_step: Option<&Closure) -> JsValue>>, x_final: Option<&Closure>, ) -> Result<(), JsValue>; + + #[wasm_bindgen(method, catch)] + pub fn register_diesel_sql_functions(this: &SQLite, database: &JsValue) -> Result<(), JsValue>; } impl std::fmt::Debug for SQLite { From dc3b588b93fb859584054891c9294c52bae75494 Mon Sep 17 00:00:00 2001 From: Andrew Plaza Date: Tue, 13 Aug 2024 16:23:55 -0400 Subject: [PATCH 28/28] make sure to always `throw error` in JS --- diesel-wasm-sqlite/package.js | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/diesel-wasm-sqlite/package.js b/diesel-wasm-sqlite/package.js index af3f1f4cf..9b4459237 100644 --- a/diesel-wasm-sqlite/package.js +++ b/diesel-wasm-sqlite/package.js @@ -217,6 +217,7 @@ export class SQLite { return this.sqlite3.finalize(stmt); } catch (error) { console.log("stmt error"); + throw error; } } @@ -271,8 +272,9 @@ export class SQLite { try { return this.sqlite3.exec(database, query); console.log("Batch exec'ed"); - } catch { + } catch (error) { console.log("exec err"); + throw error; } } @@ -298,8 +300,9 @@ export class SQLite { xFinal, ); console.log("create function"); - } catch { + } catch (error) { console.log("create function err"); + throw error; } } //TODO: At some point need a way to register functions from rust