diff --git a/.devcontainer/rust/devcontainer-feature.json b/.devcontainer/rust/devcontainer-feature.json index 0296909d2ae4..368c410bf5c3 100644 --- a/.devcontainer/rust/devcontainer-feature.json +++ b/.devcontainer/rust/devcontainer-feature.json @@ -5,7 +5,7 @@ "dependsOn": { "ghcr.io/devcontainers/features/rust:1": { // this should match the `rust-toolchain.toml` - "version": "nightly-2026-07-29", + "version": "nightly-2026-08-20", "profile": "minimal", "components": "rustfmt,clippy,rust-analyzer" } diff --git a/Cargo.lock b/Cargo.lock index 5abc2ff12304..998da60da075 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -361,13 +361,13 @@ dependencies = [ [[package]] name = "async-trait" -version = "0.1.86" +version = "0.1.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "644dd749086bf3771a2fbc5f256fdb982d53f011c7d5d560304eafeecebce79d" +checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667" dependencies = [ "proc-macro2", "quote", - "syn 2.0.104", + "syn 3.0.3", ] [[package]] @@ -9081,6 +9081,17 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "syn" +version = "3.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + [[package]] name = "sync_wrapper" version = "1.0.2" @@ -10134,7 +10145,6 @@ dependencies = [ "mockito", "quick_cache", "reqwest", - "rustc-hash 2.1.1", "rustls", "serde", "tokio", diff --git a/docs/01-app/03-api-reference/05-config/01-next-config-js/allowedDevOrigins.mdx b/docs/01-app/03-api-reference/05-config/01-next-config-js/allowedDevOrigins.mdx index d869757d714a..c819b6e1f42d 100644 --- a/docs/01-app/03-api-reference/05-config/01-next-config-js/allowedDevOrigins.mdx +++ b/docs/01-app/03-api-reference/05-config/01-next-config-js/allowedDevOrigins.mdx @@ -16,3 +16,25 @@ module.exports = { allowedDevOrigins: ['local-origin.dev', '*.local-origin.dev'], } ``` + +Only the [`hostname`](https://developer.mozilla.org/en-US/docs/Web/API/URL/hostname) of the request's `Origin` header is matched against your entries. For a request from `http://local-origin.dev:3000/dashboard?tab=1`, that is `local-origin.dev`. The scheme, the port, the path, and the query string are ignored. Write your entries that way too, without `https://` and without a port. + +A no-cors cross-site request, such as a script tag loading a dev asset, sends no `Origin` header. Those are matched on the `Referer` hostname instead. + +Entries can also expand, through two wildcards: a `*` stands in for exactly one label of the hostname, and `**` for one or more. That is why the example above lists two entries, one for the bare hostname and one for its subdomains. + +| Entry | Matches | Does not match | +| --------------------- | --------------------------------------------------- | ---------------------------------------------- | +| `local-origin.dev` | `local-origin.dev` | `team.local-origin.dev` | +| `*.local-origin.dev` | `team.local-origin.dev` | `local-origin.dev`, `team.eu.local-origin.dev` | +| `**.local-origin.dev` | `team.local-origin.dev`, `team.eu.local-origin.dev` | `local-origin.dev` | + +Partial replacement is not supported. Write `*.local-origin.dev`, rather than `team-*.local-origin.dev`. Using `**` is only supported at the start of the pattern. + +The dev server already allows `localhost`, its subdomains, and the hostname it was started with. Any other hostname needs an entry, such as a tunnel used for remote development: + +```js filename="next.config.js" +module.exports = { + allowedDevOrigins: ['*.tunnel.example.com'], +} +``` diff --git a/docs/01-app/03-api-reference/05-config/01-next-config-js/serverActions.mdx b/docs/01-app/03-api-reference/05-config/01-next-config-js/serverActions.mdx index 31724d299b6c..3b2b7c8973d7 100644 --- a/docs/01-app/03-api-reference/05-config/01-next-config-js/serverActions.mdx +++ b/docs/01-app/03-api-reference/05-config/01-next-config-js/serverActions.mdx @@ -10,7 +10,7 @@ Options for configuring Server Actions behavior in your Next.js application. For ## `allowedOrigins` -A list of extra safe origin domains from which Server Actions can be invoked. Next.js compares the origin of a Server Action request with the host domain, ensuring they match to prevent CSRF attacks. If not provided, only the same origin is allowed. +A list of extra safe hosts from which Server Actions can be invoked. To prevent CSRF attacks, Next.js compares the host in a request's `Origin` header against the app's own host, taken from `x-forwarded-host` or `host`, and rejects the action when the two differ. If not provided, only the same origin is allowed. A request that carries no `Origin` header at all is allowed through with a warning rather than rejected. ```js filename="next.config.js" /** @type {import('next').NextConfig} */ @@ -24,6 +24,38 @@ module.exports = { } ``` +Only the [`host`](https://developer.mozilla.org/en-US/docs/Web/API/URL/host) of the request's `Origin` header is matched against your entries, which is the hostname plus the port when the URL carries one. For a request from `https://my-proxy.com/checkout`, that is `my-proxy.com`. For one from `https://my-proxy.com:8443/checkout`, `my-proxy.com:8443`. Write your entries the same way. + +Entries can also expand, through two wildcards: a `*` stands in for exactly one label of the host, and `**` for one or more. That is why the example above lists two entries, one for the bare host and one for its subdomains. + +| Entry | Matches | Does not match | +| ------------------- | ----------------------------------------- | --------------------------------------- | +| `my-proxy.com` | `my-proxy.com` | `my-proxy.com:8443`, `app.my-proxy.com` | +| `*.my-proxy.com` | `app.my-proxy.com` | `my-proxy.com`, `app.my-proxy.com:8443` | +| `**.my-proxy.com` | `app.my-proxy.com`, `app.eu.my-proxy.com` | `my-proxy.com` | +| `my-proxy.com:8443` | `my-proxy.com:8443` | `my-proxy.com` | + +Partial replacement is not supported. Write `*.my-proxy.com`, rather than `app-*.my-proxy.com`. Using `**` is only supported at the start of the pattern. A port cannot be wildcarded, so write it out in full: `my-proxy.com:8443`, or `*.my-proxy.com:8443` for its subdomains. + +Behind a reverse proxy, no entry is needed as long as the proxy forwards the public host in `x-forwarded-host`. When it forwards its own host instead, the browser sends `my-proxy.com` while the server reports something like `localhost:3000`, and that mismatch is what this list is for: the host visible in the browser's address bar is the one to add, not the internal one the server reports. + +The check runs in production as well as in development, so the list applies to your deployed app and not only to local work. + +For example, remote development through a tunnel needs the tunnel hostname in two places: in [`allowedDevOrigins`](/docs/app/api-reference/config/next-config-js/allowedDevOrigins), so the dev server serves its own assets and endpoints, and here, so actions from it are accepted: + +```js filename="next.config.js" +/** @type {import('next').NextConfig} */ + +module.exports = { + allowedDevOrigins: ['*.tunnel.example.com'], + experimental: { + serverActions: { + allowedOrigins: ['*.tunnel.example.com'], + }, + }, +} +``` + ## `bodySizeLimit` By default, the maximum size of the request body sent to a Server Action is 1MB, to prevent the consumption of excessive server resources in parsing large amounts of data, as well as potential DDoS attacks. diff --git a/rust-toolchain.toml b/rust-toolchain.toml index c54d053bd636..decce1d880d2 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -1,6 +1,6 @@ # if you update this, also update `.devcontainer/rust/devcontainer-feature.json` # if you move the file, also update any turbo.json inputs that references it. [toolchain] -channel = "nightly-2026-07-29" +channel = "nightly-2026-08-20" components = ["rustfmt", "clippy", "rust-analyzer"] profile = "minimal" diff --git a/turbopack/crates/turbo-rcstr/Cargo.toml b/turbopack/crates/turbo-rcstr/Cargo.toml index 19f632f496de..0c0986f61378 100644 --- a/turbopack/crates/turbo-rcstr/Cargo.toml +++ b/turbopack/crates/turbo-rcstr/Cargo.toml @@ -28,7 +28,10 @@ napi = { workspace = true, optional = true } [target.'cfg(not(target_family = "wasm"))'.dependencies] scattered-collect = { workspace = true } -[dev-dependencies] +[target.'cfg(not(target_family = "wasm"))'.dev-dependencies] +# Only used by the benchmarks, which don't run on wasm. Gated by target so that +# `cargo test -p turbo-rcstr --lib --target wasm32-wasip1-threads` can build: criterion pulls in +# rayon, which refuses to compile for wasi, and cargo resolves dev-dependencies even for `--lib`. criterion = { workspace = true } [lints] diff --git a/turbopack/crates/turbo-rcstr/src/lib.rs b/turbopack/crates/turbo-rcstr/src/lib.rs index fe6afc96e180..4deda1869c2d 100644 --- a/turbopack/crates/turbo-rcstr/src/lib.rs +++ b/turbopack/crates/turbo-rcstr/src/lib.rs @@ -778,6 +778,65 @@ mod tests { } }; assert_eq!(STR, RcStr::from("hello")); + + // A literal one byte past the capacity must not inline, on either width. + let too_long = "x".repeat(MAX_INLINE_LEN + 1); + assert!(inline_atom(&too_long).is_none()); + } + + /// The inline capacity must be the same on every target. `turbo-rcstr-macros` runs on the + /// *host*, so it decides inline-vs-static using a host-side constant; if the target disagreed, + /// the macro would emit `inline_atom(..).unwrap()` for a literal that does not fit and panic at + /// runtime. This is the regression guard for that. + #[test] + #[cfg(not(feature = "atom_size_128"))] + fn max_inline_len_is_uniform_across_targets() { + assert_eq!( + MAX_INLINE_LEN, 7, + "MAX_INLINE_LEN must be 7 on every target, including 32-bit/wasm" + ); + assert_eq!(size_of::(), 8); + // The non-zero niche must survive, or `Option` silently doubles in size. + assert_eq!(size_of::>(), size_of::()); + } + + /// `rcstr!` expands to a `const`, so it must stay const-evaluable on every target. On 32-bit + /// this only works because `TaggedValue` holds the address in a real pointer field: a bare + /// integer representation would need a pointer→integer cast, which const evaluation forbids, + /// and every literal taking the static path would fail with `E0080`. + #[test] + fn rcstr_macro_is_const_on_every_target() { + // Short enough to be stored inline. + const SHORT: RcStr = rcstr!("abc"); + // Longer than the inline capacity, so this takes the static path — the one that needs the + // pointer to survive const evaluation. + const LONG: RcStr = rcstr!("a string that is definitely not inline"); + + assert_eq!(SHORT, RcStr::from("abc")); + assert_eq!(LONG, RcStr::from("a string that is definitely not inline")); + assert_eq!(SHORT.tag(), INLINE_TAG); + assert_eq!(LONG.tag(), STATIC_TAG); + } + + /// Round-trips across the inline/static boundary. Lengths 4..=7 are the interesting band: they + /// are inline at capacity 7 but would spill to the static path at capacity 3, so this fails if + /// the representation ever diverges by target again. + #[test] + fn round_trip_across_the_inline_boundary() { + for len in 0..=9usize { + let s = "abcdefghi"[..len].to_string(); + let r = RcStr::from(s.as_str()); + assert_eq!(r.as_str(), s, "round trip failed at len {len}"); + assert_eq!(r.len(), len); + + let expected_inline = len <= MAX_INLINE_LEN; + assert_eq!( + r.tag() == INLINE_TAG, + expected_inline, + "len {len} should {} be inline (MAX_INLINE_LEN = {MAX_INLINE_LEN})", + if expected_inline { "" } else { "not" } + ); + } } #[test] @@ -833,6 +892,9 @@ mod tests { } #[test] + // `STATIC_RCSTRS` is an empty array on wasm (see its definition above), so there is no static + // registry for the decoder to resolve against and the value comes back as `DYNAMIC_TAG`. + #[cfg_attr(target_family = "wasm", ignore = "no static RcStr registry on wasm")] fn test_bincode_roundtrip() { use turbo_bincode::{turbo_bincode_decode, turbo_bincode_encode}; diff --git a/turbopack/crates/turbo-rcstr/src/tagged_value.rs b/turbopack/crates/turbo-rcstr/src/tagged_value.rs index b7bb4df9ba41..7d200e7b871d 100644 --- a/turbopack/crates/turbo-rcstr/src/tagged_value.rs +++ b/turbopack/crates/turbo-rcstr/src/tagged_value.rs @@ -1,14 +1,45 @@ -#![allow(clippy::missing_transmute_annotations)] +//! The tagged value that backs [`crate::RcStr`]. +//! +//! An `RcStr` is a single 8-byte value (16 with `atom_size_128`) that packs a 2-bit tag with a +//! payload: a pointer to a static or `Arc`'d string, or up to [`MAX_INLINE_LEN`] bytes of string +//! data stored inline. The tag lives in the low 2 bits of the value's least significant byte, +//! which is why pointers must be at least 4-byte aligned. +//! +//! # Why the narrow-pointer targets use a struct rather than an integer +//! +//! `rcstr!` expands to a `const`, so both constructors below have to be usable during const +//! evaluation. Const evaluation is asymmetric about pointer/integer conversions: +//! +//! * **pointer → integer is forbidden.** During const evaluation a pointer is an abstract +//! (allocation, offset) pair; the numeric address does not exist yet because the linker chooses +//! it. No spelling avoids this — `transmute`, `as`, `expose_provenance` and `repr(C)` union +//! punning are all rejected. +//! * **integer → pointer is allowed.** The result simply carries no provenance, which is fine so +//! long as it is never dereferenced. +//! +//! On 64-bit targets the payload is a `NonNull`, so [`TaggedValue::new_ptr`] is a pointer→pointer +//! cast and [`TaggedValue::new_tag`] is an integer→pointer transmute: both permitted. If narrower +//! targets stored a bare `u64` instead, `new_ptr` would need the one conversion that is impossible +//! and every `rcstr!` taking the static path would fail to compile with +//! `error[E0080]: unable to turn pointer into integer`. +//! +//! So those targets keep the value 8 bytes wide — giving the same [`MAX_INLINE_LEN`] as +//! everywhere else — but hold the address in a real pointer field paired with a byte payload. The +//! payload is sized to the pointer width so there is no padding: padding bytes would be +//! uninitialised, which would make the whole-value transmute in `new_tag` invalid. +//! +//! The field order follows endianness so that the pointer's least significant byte always lands +//! where the value's least significant byte lives — offset 0 on little-endian, the last byte on +//! big-endian. That is where [`TaggedValue::tag_byte`] reads the tag. With a fixed field +//! order, a big-endian dynamic pointer's tag bits would be read out of the payload (always zero) +//! and misread as `STATIC_TAG`. +//! +//! Reading the value back as an integer (`get_ptr`, `get_value`, `tag_byte`) only ever happens at +//! run time, where pointer → integer is perfectly legal. use std::{num::NonZeroU8, os::raw::c_void, ptr::NonNull, slice}; use self::raw_types::*; -#[cfg(not(any( - target_pointer_width = "32", - target_pointer_width = "16", - feature = "atom_size_64", - feature = "atom_size_128" -)))] use crate::TAG_MASK; #[cfg(feature = "atom_size_128")] @@ -17,23 +48,85 @@ mod raw_types { pub type RawTaggedNonZeroValue = std::num::NonZeroU128; } +/// The narrow-pointer arm: an 8-byte value built from a real pointer plus a byte payload, so that +/// both constructors stay const-evaluable. See the module docs. #[cfg(all( - any( - target_pointer_width = "32", - target_pointer_width = "16", - feature = "atom_size_64" - ), + any(target_pointer_width = "32", target_pointer_width = "16"), not(feature = "atom_size_128") ))] mod raw_types { + use std::ptr::NonNull; + pub type RawTaggedValue = u64; - pub type RawTaggedNonZeroValue = std::num::NonZeroU64; + + /// Padding that brings the value up to 8 bytes, sized so that there is none left over. + #[cfg(target_pointer_width = "32")] + pub type Payload = [u8; 4]; + #[cfg(target_pointer_width = "16")] + pub type Payload = [u8; 6]; + + // Both layouts are declared unconditionally so that the layout assertions for *both* are + // compiled on every target; only the alias below is conditional. Otherwise the big-endian + // invariant would never be checked on a little-endian host. + // + // `align(8)` is required, not cosmetic: a pointer field only forces 4-byte (or 2-byte) + // alignment, but the value is read back as a `u64` to extract the tag, and wasm traps on an + // unaligned 64-bit load with `RuntimeError: operation does not support unaligned accesses`. + // Aligning to the width of the integer view keeps that read legal without adding padding. + #[repr(C, align(8))] + #[derive(Copy, Clone, Debug, PartialEq, Eq)] + pub struct RawLittle { + pub ptr: NonNull<()>, + pub pad: Payload, + } + + #[repr(C, align(8))] + #[derive(Copy, Clone, Debug, PartialEq, Eq)] + pub struct RawBig { + pub pad: Payload, + pub ptr: NonNull<()>, + } + + #[cfg(target_endian = "little")] + pub type RawTaggedNonZeroValue = RawLittle; + #[cfg(target_endian = "big")] + pub type RawTaggedNonZeroValue = RawBig; + + // The pointer's least significant byte must coincide with the value's least significant byte. + const _: () = assert!( + std::mem::offset_of!(RawLittle, ptr) == 0, + "little-endian: the pointer must start at offset 0" + ); + const _: () = assert!( + std::mem::offset_of!(RawBig, ptr) == std::mem::size_of::(), + "big-endian: the pointer must follow the payload" + ); + // No padding: `new_tag` transmutes the whole value, and padding bytes are uninitialised. + // With `align(8)` and a payload sized to the pointer width, the fields fill the value exactly. + const _: () = assert!( + std::mem::size_of::() + == std::mem::size_of::>() + std::mem::size_of::(), + "the layout must not contain padding" + ); + const _: () = assert!( + std::mem::size_of::() + == std::mem::size_of::>() + std::mem::size_of::(), + "the layout must not contain padding" + ); + // The integer view of the value must be legal to load, i.e. at least as aligned as a `u64`. + const _: () = assert!( + std::mem::align_of::() >= std::mem::align_of::(), + "the value is read back as a u64, which wasm requires to be aligned" + ); + const _: () = assert!( + std::mem::align_of::() >= std::mem::align_of::(), + "the value is read back as a u64, which wasm requires to be aligned" + ); } #[cfg(not(any( target_pointer_width = "32", target_pointer_width = "16", - feature = "atom_size_64", feature = "atom_size_128" )))] mod raw_types { @@ -43,6 +136,19 @@ mod raw_types { pub(crate) const MAX_INLINE_LEN: usize = std::mem::size_of::() - 1; +// The inline capacity must not depend on the target, or `turbo-rcstr-macros` (which runs on the +// host) could not decide inline-vs-static on the target's behalf. +#[cfg(not(feature = "atom_size_128"))] +const _: () = assert!( + std::mem::size_of::() == 8, + "TaggedValue must be 8 bytes on every target so MAX_INLINE_LEN is uniformly 7" +); +#[cfg(feature = "atom_size_128")] +const _: () = assert!( + std::mem::size_of::() == 16 && MAX_INLINE_LEN == 15, + "atom_size_128 must stay a 16-byte value with 15 inline bytes" +); + #[derive(Copy, Clone, Debug, PartialEq, Eq)] #[repr(transparent)] pub(crate) struct TaggedValue { @@ -52,13 +158,37 @@ pub(crate) struct TaggedValue { impl TaggedValue { #[inline(always)] pub const fn new_ptr(value: NonNull) -> Self { - #[cfg(any( - target_pointer_width = "32", - target_pointer_width = "16", - feature = "atom_size_64", - feature = "atom_size_128" + // A pointer → pointer cast, which const evaluation permits. See the module docs for why + // the narrow-pointer arm cannot store a bare integer here. + #[cfg(all( + any(target_pointer_width = "32", target_pointer_width = "16"), + not(feature = "atom_size_128") ))] + { + #[cfg(target_endian = "little")] + { + Self { + value: RawTaggedNonZeroValue { + ptr: value.cast(), + pad: [0; std::mem::size_of::()], + }, + } + } + #[cfg(target_endian = "big")] + { + Self { + value: RawTaggedNonZeroValue { + pad: [0; std::mem::size_of::()], + ptr: value.cast(), + }, + } + } + } + + #[cfg(feature = "atom_size_128")] unsafe { + // `atom_size_128` keeps its integer representation, so this arm still cannot be used + // in a const context. It is not enabled anywhere in this workspace. let value: std::num::NonZeroUsize = std::mem::transmute(value); Self { value: RawTaggedNonZeroValue::new_unchecked(value.get() as _), @@ -68,7 +198,6 @@ impl TaggedValue { #[cfg(not(any( target_pointer_width = "32", target_pointer_width = "16", - feature = "atom_size_64", feature = "atom_size_128" )))] { @@ -80,30 +209,34 @@ impl TaggedValue { #[inline(always)] pub const fn new_tag(value: NonZeroU8) -> Self { + // An integer → pointer transmute, which const evaluation permits. let value = value.get() as RawTaggedValue; Self { #[allow(clippy::transmute_int_to_non_zero)] - value: unsafe { std::mem::transmute(value) }, + value: unsafe { std::mem::transmute::(value) }, } } #[inline(always)] pub fn get_ptr(&self) -> *const c_void { - #[cfg(any( - target_pointer_width = "32", - target_pointer_width = "16", - feature = "atom_size_64", - feature = "atom_size_128" + #[cfg(all( + any(target_pointer_width = "32", target_pointer_width = "16"), + not(feature = "atom_size_128") ))] { - use crate::TAG_MASK; - + // The tag lives in the low bits of the pointer itself (`DYNAMIC_TAG` sets one), so + // mask it before use — otherwise a dynamic string's `Arc` is dereferenced two bytes + // off, which traps on wasm as an unaligned atomic access. + // Reading the address is fine here: this only ever runs at run time. + (self.value.ptr.as_ptr() as usize & !(TAG_MASK as usize)) as _ + } + #[cfg(feature = "atom_size_128")] + { (self.value.get() as usize & !(TAG_MASK as usize)) as _ } #[cfg(not(any( target_pointer_width = "32", target_pointer_width = "16", - feature = "atom_size_64", feature = "atom_size_128" )))] { @@ -113,7 +246,26 @@ impl TaggedValue { #[inline(always)] fn get_value(&self) -> RawTaggedValue { - unsafe { std::mem::transmute(Some(self.value)) } + #[cfg(all( + any(target_pointer_width = "32", target_pointer_width = "16"), + not(feature = "atom_size_128") + ))] + { + // The layout is guaranteed padding-free and 8-aligned above, so reading the whole + // value as an integer is well defined. Again, run time only. + unsafe { std::mem::transmute::(self.value) } + } + #[cfg(not(all( + any(target_pointer_width = "32", target_pointer_width = "16"), + not(feature = "atom_size_128") + )))] + { + unsafe { + std::mem::transmute::, RawTaggedValue>(Some( + self.value, + )) + } + } } #[inline(always)] diff --git a/turbopack/crates/turbo-tasks-fetch/Cargo.toml b/turbopack/crates/turbo-tasks-fetch/Cargo.toml index 6cf005e9defd..e83753a00464 100644 --- a/turbopack/crates/turbo-tasks-fetch/Cargo.toml +++ b/turbopack/crates/turbo-tasks-fetch/Cargo.toml @@ -61,6 +61,11 @@ webpki-root-certs = "1" [target.'cfg(all(windows, target_arch = "aarch64"))'.dependencies] reqwest = { workspace = true, features = ["native-tls"] } +# On wasm there is no usable HTTP client (see `src/wasm_reqwest.rs`), so `reqwest` is not a +# dependency there and the local stand-in is used instead. It only needs a hash map. +[target.'cfg(target_family = "wasm")'.dependencies] +rustc-hash = { workspace = true } + [dev-dependencies] mockito = { version = "1.7.0", default-features = false } tokio = { workspace = true, features = ["full"] } diff --git a/turbopack/crates/turbo-tasks-fetch/src/client.rs b/turbopack/crates/turbo-tasks-fetch/src/client.rs index 2b7240566909..f8ed75656123 100644 --- a/turbopack/crates/turbo-tasks-fetch/src/client.rs +++ b/turbopack/crates/turbo-tasks-fetch/src/client.rs @@ -14,6 +14,9 @@ use turbo_tasks::{ ResolvedVc, Vc, duration_span, util::StaticOrArc, }; +// Route every `reqwest::…` path in this module to the local stand-in on wasm. +#[cfg(target_family = "wasm")] +use crate::wasm_reqwest as reqwest; use crate::{FetchError, FetchResult, HttpResponse, HttpResponseBody}; const MAX_CLIENTS: usize = 16; diff --git a/turbopack/crates/turbo-tasks-fetch/src/error.rs b/turbopack/crates/turbo-tasks-fetch/src/error.rs index 08bb5350d5c5..37c88544cb2f 100644 --- a/turbopack/crates/turbo-tasks-fetch/src/error.rs +++ b/turbopack/crates/turbo-tasks-fetch/src/error.rs @@ -5,6 +5,10 @@ use turbo_tasks::{ResolvedVc, Vc}; use turbo_tasks_fs::FileSystemPath; use turbopack_core::issue::{Issue, IssueSeverity, IssueStage, StyledString}; +// Route every `reqwest::…` path in this module to the local stand-in on wasm. +#[cfg(target_family = "wasm")] +use crate::wasm_reqwest as reqwest; + #[derive(Debug)] #[turbo_tasks::value(shared)] pub enum FetchErrorKind { diff --git a/turbopack/crates/turbo-tasks-fetch/src/lib.rs b/turbopack/crates/turbo-tasks-fetch/src/lib.rs index 8b037cf9c00e..a5170b70de6b 100644 --- a/turbopack/crates/turbo-tasks-fetch/src/lib.rs +++ b/turbopack/crates/turbo-tasks-fetch/src/lib.rs @@ -5,6 +5,10 @@ mod client; mod error; mod response; +// A non-functional stand-in for `reqwest` on wasm; see the module docs for why reqwest cannot be +// used there. +#[cfg(target_family = "wasm")] +mod wasm_reqwest; pub use crate::{ client::{ diff --git a/turbopack/crates/turbo-tasks-fetch/src/wasm_reqwest.rs b/turbopack/crates/turbo-tasks-fetch/src/wasm_reqwest.rs new file mode 100644 index 000000000000..3daf18abac95 --- /dev/null +++ b/turbopack/crates/turbo-tasks-fetch/src/wasm_reqwest.rs @@ -0,0 +1,183 @@ +//! Reports HTTP as unsupported on wasm, in the shape of the `reqwest` API this crate consumes. +//! +//! This is **not** a client and does not try to look like one: building a client fails immediately +//! with a clear error, so no request is ever attempted, nothing is retried, and no response is ever +//! produced. The remaining types exist only so that [`crate::client`] type-checks; they are +//! unreachable. +//! +//! `reqwest` itself cannot serve wasm here. Its only wasm backend targets `wasm32-unknown-unknown` +//! and is built on the browser `fetch` API via `wasm-bindgen`. Under `wasm32-wasip1-threads` that +//! backend is still selected (it keys off `target_arch = "wasm32"`), and it is both +//! API-incompatible (no `ClientBuilder::connect_timeout`, no `ClientBuilder::timeout`, no +//! `Error::is_connect`) and — fatally — `!Send`, which `turbo-tasks` requires of every task future. +//! WASI preview1 has no sockets to build a native client on either. +//! +//! Supporting HTTP on wasm needs the host to provide it: for wasm builds of the Next.js bindings +//! that means a napi callback into the JS `fetch`, kept behind the existing +//! [`crate::FetchClientConfig`] interface so callers are unaffected. That is deliberately a +//! separate change, because it cannot be tested until the wasm bindings can be instantiated. Until +//! then the only consumer, `next/font/google`, reports this error instead of silently producing +//! nothing. + +use std::{fmt, time::Duration}; + +pub type Result = std::result::Result; + +/// The only value this module ever produces. +#[derive(Debug)] +pub struct Error; + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str( + "HTTP requests are not supported in wasm builds of Next.js: this platform has no HTTP \ + client. Features that fetch at build time, such as `next/font/google`, cannot be \ + used here — self-host the assets, or use a platform with native Next.js binaries.", + ) + } +} + +impl std::error::Error for Error {} + +impl Error { + /// Not a connection failure — the platform has no client at all, so retrying cannot help. + pub fn is_connect(&self) -> bool { + false + } + + /// Not a timeout, for the same reason. + pub fn is_timeout(&self) -> bool { + false + } + + pub fn is_request(&self) -> bool { + true + } + + pub fn status(&self) -> Option { + None + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct StatusCode(u16); + +impl StatusCode { + pub fn as_u16(self) -> u16 { + self.0 + } + + pub fn is_server_error(self) -> bool { + (500..600).contains(&self.0) + } +} + +#[derive(Clone, Debug, Default)] +pub struct Client; + +impl Client { + pub fn builder() -> ClientBuilder { + ClientBuilder + } + + /// Unreachable: [`ClientBuilder::build`] never yields a `Client`. + pub fn get(&self, _url: &str) -> RequestBuilder { + unreachable!("no HTTP client can be built on wasm") + } +} + +#[derive(Clone, Debug)] +pub struct ClientBuilder; + +impl ClientBuilder { + pub fn connect_timeout(self, _timeout: Duration) -> Self { + self + } + + pub fn timeout(self, _timeout: Duration) -> Self { + self + } + + /// Fails, so callers get the error at client construction rather than per request. + pub fn build(self) -> Result { + Err(Error) + } +} + +#[derive(Clone, Debug)] +pub struct RequestBuilder; + +impl RequestBuilder { + pub fn header(self, _name: &str, _value: &str) -> Self { + self + } + + pub fn try_clone(&self) -> Option { + Some(RequestBuilder) + } + + /// Unreachable: a `RequestBuilder` requires a `Client`, which cannot be built. + pub async fn send(self) -> Result { + Err(Error) + } +} + +/// Unreachable: no request is ever sent, so no response is ever constructed. +#[derive(Debug)] +pub struct Response { + _priv: (), +} + +impl Response { + pub fn error_for_status(self) -> Result { + Err(Error) + } + + pub fn status(&self) -> StatusCode { + unreachable!("no response can be produced on wasm") + } + + pub fn headers(&self) -> &header::HeaderMap { + unreachable!("no response can be produced on wasm") + } + + pub async fn bytes(self) -> Result> { + Err(Error) + } +} + +pub mod header { + use rustc_hash::FxHashMap; + + pub const CACHE_CONTROL: &str = "cache-control"; + + #[derive(Clone, Debug, Default)] + pub struct HeaderValue(String); + + impl HeaderValue { + pub fn from_static(value: &'static str) -> Self { + HeaderValue(value.to_string()) + } + + pub fn to_str(&self) -> Result<&str, std::str::Utf8Error> { + Ok(&self.0) + } + } + + #[derive(Clone, Debug, Default)] + pub struct HeaderMap(FxHashMap); + + impl HeaderMap { + pub fn new() -> Self { + Self::default() + } + + pub fn insert(&mut self, name: &str, value: HeaderValue) -> Option { + self.0.insert(name.to_ascii_lowercase(), value) + } + + pub fn get(&self, name: &str) -> Option<&HeaderValue> { + self.0.get(&name.to_ascii_lowercase()) + } + } +} diff --git a/turbopack/crates/turbopack-core/src/compile_time_info.rs b/turbopack/crates/turbopack-core/src/compile_time_info.rs index 78251711e23a..62c71ec1757a 100644 --- a/turbopack/crates/turbopack-core/src/compile_time_info.rs +++ b/turbopack/crates/turbopack-core/src/compile_time_info.rs @@ -271,7 +271,7 @@ impl From for DefinableNameSegment { } } -#[derive(PartialEq, Eq)] +#[derive(Copy, Clone, PartialEq, Eq)] pub enum DefinableNameSegmentRef<'a> { Name(&'a str), Call(&'a str), @@ -310,7 +310,7 @@ impl Equivalent for DefinableNameSegmentRef<'_> { } } -#[derive(PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq)] pub struct DefinableNameSegmentRefs<'a>(pub SmallVec<[DefinableNameSegmentRef<'a>; 4]>); // Hash can't be derived because it must match Vec's Hash. diff --git a/turbopack/crates/turbopack-ecmascript/src/analyzer/graph/effects.rs b/turbopack/crates/turbopack-ecmascript/src/analyzer/graph/effects.rs index c135fb26ce7f..3f804c104182 100644 --- a/turbopack/crates/turbopack-ecmascript/src/analyzer/graph/effects.rs +++ b/turbopack/crates/turbopack-ecmascript/src/analyzer/graph/effects.rs @@ -151,6 +151,12 @@ pub enum Effect<'a> { ast_path: BumpBox<'a, [AstParentKind]>, span: Span, }, + /// A property access created by an object destructuring pattern. + DestructuredMember { + obj: BumpBox<'a, JsValue<'a>>, + prop: BumpBox<'a, JsValue<'a>>, + span: Span, + }, /// A `x in y` expression. In { left: BumpBox<'a, JsValue<'a>>, @@ -235,6 +241,10 @@ impl<'a> Effect<'a> { obj.normalize(arena); prop.normalize(arena); } + Effect::DestructuredMember { obj, prop, .. } => { + obj.normalize(arena); + prop.normalize(arena); + } Effect::In { left, right, .. } => { left.normalize(arena); right.normalize(arena); diff --git a/turbopack/crates/turbopack-ecmascript/src/analyzer/graph/visitor.rs b/turbopack/crates/turbopack-ecmascript/src/analyzer/graph/visitor.rs index 8e7c4a3fe439..64713f8665ab 100644 --- a/turbopack/crates/turbopack-ecmascript/src/analyzer/graph/visitor.rs +++ b/turbopack/crates/turbopack-ecmascript/src/analyzer/graph/visitor.rs @@ -1769,28 +1769,26 @@ impl VisitAstPath for Analyzer<'_, '_> { member_expr: &'ast MemberExpr, ast_path: &mut AstNodePath>, ) { - if self.analyze_mode.is_code_gen() { - let obj_value = BumpBox::new_in( - self.eval_context.eval(self.arena, &member_expr.obj), + let obj_value = BumpBox::new_in( + self.eval_context.eval(self.arena, &member_expr.obj), + self.arena, + ); + let prop_value = match &member_expr.prop { + // TODO avoid clone + MemberProp::Ident(i) => Some(BumpBox::new_in(i.sym.clone().into(), self.arena)), + MemberProp::PrivateName(_) => None, + MemberProp::Computed(ComputedPropName { expr, .. }) => Some(BumpBox::new_in( + self.eval_context.eval(self.arena, expr), self.arena, - ); - let prop_value = match &member_expr.prop { - // TODO avoid clone - MemberProp::Ident(i) => Some(BumpBox::new_in(i.sym.clone().into(), self.arena)), - MemberProp::PrivateName(_) => None, - MemberProp::Computed(ComputedPropName { expr, .. }) => Some(BumpBox::new_in( - self.eval_context.eval(self.arena, expr), - self.arena, - )), - }; - if let Some(prop_value) = prop_value { - self.add_effect(Effect::Member { - obj: obj_value, - prop: prop_value, - ast_path: as_parent_path_in(self.arena, ast_path), - span: member_expr.span(), - }); - } + )), + }; + if let Some(prop_value) = prop_value { + self.add_effect(Effect::Member { + obj: obj_value, + prop: prop_value, + ast_path: as_parent_path_in(self.arena, ast_path), + span: member_expr.span(), + }); } member_expr.visit_children_with_ast_path(self, ast_path); @@ -1801,7 +1799,7 @@ impl VisitAstPath for Analyzer<'_, '_> { bin_expr: &'ast BinExpr, ast_path: &mut AstNodePath>, ) { - if self.analyze_mode.is_code_gen() && bin_expr.op == BinaryOp::In { + if bin_expr.op == BinaryOp::In { let left_value = BumpBox::new_in( self.eval_context.eval(self.arena, &bin_expr.left), self.arena, @@ -2320,6 +2318,19 @@ impl VisitAstPath for Analyzer<'_, '_> { self.handle_object_pat_with_value(obj, value, &mut ast_path); } + Pat::Assign(assign) => { + let mut value = value.unwrap_or_else(|| { + JsValue::unknown_empty(false, rcstr!("pattern without value")) + }); + value.add_alt( + self.arena, + self.eval_context.eval(self.arena, &assign.right), + ); + self.with_pat_value(Some(value), |this| { + pat.visit_children_with_ast_path(this, ast_path); + }); + } + _ => pat.visit_children_with_ast_path(self, ast_path), } } @@ -3062,6 +3073,13 @@ impl<'a> Analyzer<'a, '_> { )); key.visit_with_ast_path(self, &mut ast_path); } + + self.add_effect(Effect::DestructuredMember { + obj: BumpBox::new_in(pat_value.clone_in(self.arena), self.arena), + prop: BumpBox::new_in(key_value.clone_in(self.arena), self.arena), + span: key.span(), + }); + let pat_value = Some(JsValue::member( self.arena, pat_value.clone_in(self.arena), @@ -3081,7 +3099,7 @@ impl<'a> Analyzer<'a, '_> { ObjectPatPropField::Assign, )); let AssignPatProp { key, value, .. } = assign; - let key_value = key.sym.clone().into(); + let key_value = JsValue::from(key.sym.clone()); { let mut ast_path = ast_path.with_guard(AstParentNodeRef::AssignPatProp( assign, @@ -3089,6 +3107,13 @@ impl<'a> Analyzer<'a, '_> { )); key.visit_with_ast_path(self, &mut ast_path); } + + self.add_effect(Effect::DestructuredMember { + obj: BumpBox::new_in(pat_value.clone_in(self.arena), self.arena), + prop: BumpBox::new_in(key_value.clone_in(self.arena), self.arena), + span: key.span(), + }); + self.add_value( key.to_id(), if let Some(box value) = value { diff --git a/turbopack/crates/turbopack-ecmascript/src/analyzer/mod.rs b/turbopack/crates/turbopack-ecmascript/src/analyzer/mod.rs index cca8511e48b1..99c83b3a77f0 100644 --- a/turbopack/crates/turbopack-ecmascript/src/analyzer/mod.rs +++ b/turbopack/crates/turbopack-ecmascript/src/analyzer/mod.rs @@ -737,6 +737,7 @@ mod tests { Effect::ImportMeta { .. } | Effect::ImportedBinding { .. } | Effect::Member { .. } + | Effect::DestructuredMember { .. } | Effect::In { .. } => 0, }; let time = start.elapsed(); diff --git a/turbopack/crates/turbopack-ecmascript/src/lib.rs b/turbopack/crates/turbopack-ecmascript/src/lib.rs index 34455951126c..32b6324799cf 100644 --- a/turbopack/crates/turbopack-ecmascript/src/lib.rs +++ b/turbopack/crates/turbopack-ecmascript/src/lib.rs @@ -423,11 +423,33 @@ pub trait EcmascriptParsable { fn failsafe_parse(self: Vc) -> Vc; } +#[turbo_tasks::value(shared)] +#[derive(Default, Debug)] +pub struct EnvVarInfo { + /// List of environment variables that are referenced (but not inlined) in the module. + pub runtime: Vec, + // TODO add this back once we can do it without regressing performance + // Whether the module potentially references all environment variables (because of a + // non-statically analyzeable `process.env`). + // pub runtime_all: Option, +} + +#[turbo_tasks::value_impl] +impl EnvVarInfo { + #[turbo_tasks::function] + pub fn empty() -> Vc { + Self::default().cell() + } +} + #[turbo_tasks::value_trait] pub trait EcmascriptAnalyzable: Module { #[turbo_tasks::function] fn analyze(self: Vc) -> Vc; + #[turbo_tasks::function] + fn env_var_info(self: Vc) -> Vc; + /// Generates module contents without an analysis pass. This is useful for /// transforming code that is not a module, e.g. runtime code. #[turbo_tasks::function] @@ -590,6 +612,11 @@ impl EcmascriptAnalyzable for EcmascriptModuleAsset { analyze_ecmascript_module(self, None) } + #[turbo_tasks::function] + async fn env_var_info(self: Vc) -> Result> { + Ok(*self.analyze().await?.env_var_info) + } + /// Generates module contents without an analysis pass. This is useful for /// transforming code that is not a module, e.g. runtime code. #[turbo_tasks::function] diff --git a/turbopack/crates/turbopack-ecmascript/src/module_fragments/part/module.rs b/turbopack/crates/turbopack-ecmascript/src/module_fragments/part/module.rs index 90fb67b543e3..ed2b2b38aad3 100644 --- a/turbopack/crates/turbopack-ecmascript/src/module_fragments/part/module.rs +++ b/turbopack/crates/turbopack-ecmascript/src/module_fragments/part/module.rs @@ -13,7 +13,7 @@ use turbopack_core::{ use crate::{ AnalyzeEcmascriptModuleResult, EcmascriptAnalyzable, EcmascriptAnalyzableExt, EcmascriptModuleAsset, EcmascriptModuleContent, EcmascriptModuleContentOptions, - EcmascriptParsable, + EcmascriptParsable, EnvVarInfo, chunk::{ EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports, ecmascript_chunk_item, @@ -56,6 +56,11 @@ impl EcmascriptAnalyzable for EcmascriptModulePartAsset { analyze_ecmascript_module(*self.full_module, Some(self.part.clone())) } + #[turbo_tasks::function] + async fn env_var_info(self: Vc) -> Result> { + Ok(*self.analyze().await?.env_var_info) + } + #[turbo_tasks::function] fn module_content_without_analysis( &self, diff --git a/turbopack/crates/turbopack-ecmascript/src/references/mod.rs b/turbopack/crates/turbopack-ecmascript/src/references/mod.rs index 9f9ed390f1f2..e414ef55724a 100644 --- a/turbopack/crates/turbopack-ecmascript/src/references/mod.rs +++ b/turbopack/crates/turbopack-ecmascript/src/references/mod.rs @@ -20,6 +20,8 @@ pub mod raw; pub mod removal; pub mod require_context; pub mod service_worker; +#[cfg(test)] +mod tests; pub mod type_issue; pub mod typescript; pub mod util; @@ -97,7 +99,7 @@ use worker::{WorkerAssetReference, WorkerGlobalPlaceholder, WorkerGlobalsReplace pub use crate::references::esm::export::{FollowExportsResult, follow_reexports}; use crate::{ - AnalyzeMode, EcmascriptModuleAsset, EcmascriptModuleAssetType, EcmascriptParsable, + AnalyzeMode, EcmascriptModuleAsset, EcmascriptModuleAssetType, EcmascriptParsable, EnvVarInfo, ModuleTypeResult, TypeofWindow, analyzer::{ Bump, BumpVec, ConstantNumber, ConstantString, ConstantValue as JsConstantValue, JsValue, @@ -175,6 +177,8 @@ pub struct AnalyzeEcmascriptModuleResult { /// Present when the module is a statically-analyzable CommonJS module; /// carries its named exports for scope hoisting. pub cjs_static_exports: Option, + + pub env_var_info: ResolvedVc, } #[turbo_tasks::value_impl] @@ -233,6 +237,9 @@ struct AnalyzeEcmascriptModuleResultBuilder { source_map: Option>>, side_effects: ModuleSideEffects, cjs_static_exports: Option, + + env_var_info_runtime: FxIndexSet, + #[cfg(debug_assertions)] ident: RcStr, } @@ -253,6 +260,7 @@ impl AnalyzeEcmascriptModuleResultBuilder { source_map: None, side_effects: ModuleSideEffects::SideEffectful, cjs_static_exports: None, + env_var_info_runtime: Default::default(), #[cfg(debug_assertions)] ident: Default::default(), } @@ -334,6 +342,11 @@ impl AnalyzeEcmascriptModuleResultBuilder { self.successful = successful; } + /// Adds a runtime environment variable reference to the analysis result. + pub fn add_runtime_env_var_reference(&mut self, runtime_env: RcStr) { + self.env_var_info_runtime.insert(runtime_env); + } + pub fn add_esm_reference_namespace_resolved( &mut self, esm_reference_idx: usize, @@ -440,6 +453,10 @@ impl AnalyzeEcmascriptModuleResultBuilder { successful: self.successful, source_map: self.source_map, cjs_static_exports: self.cjs_static_exports, + env_var_info: EnvVarInfo { + runtime: self.env_var_info_runtime.into_iter().collect(), + } + .resolved_cell(), }, )) } @@ -1277,11 +1294,6 @@ async fn analyze_ecmascript_module_internal( ast_path, span, } => { - debug_assert!( - analyze_mode.is_code_gen(), - "unexpected Effect::Member in tracing mode" - ); - // Intentionally not awaited because `handle_member` reads this only when needed let obj = analysis_state.link_value(take(&mut *obj), ImportAttributes::empty_ref()); @@ -1293,17 +1305,44 @@ async fn analyze_ecmascript_module_internal( handle_member(&ast_path, obj, prop, span, &analysis_state, &mut analysis) .await?; } + Effect::DestructuredMember { + mut obj, + mut prop, + span: _, + } => { + // TODO add an inlining codegen here + + let prop = analysis_state + .link_value(take(&mut *prop), ImportAttributes::empty_ref()) + .await?; + if let Some(prop) = prop.as_str() { + // This is only used for env var tracking. The more robust solution would be + // an `Effect::Ident` but that would be even more + // expensive. + let obj = analysis_state + .link_value(take(&mut *obj), ImportAttributes::empty_ref()) + .await?; + + if let Some((name, false)) = + obj.get_definable_name(Some(&analysis_state.var_graph)) + && matches!( + name.0.as_slice(), + [ + DefinableNameSegmentRef::Name("process"), + DefinableNameSegmentRef::Name("env") + ] + ) + { + analysis.add_runtime_env_var_reference(RcStr::from(prop)); + } + } + } Effect::In { mut left, mut right, ast_path, - span: _, + span, } => { - debug_assert!( - analyze_mode.is_code_gen(), - "unexpected Effect::In in tracing mode" - ); - // Intentionally not awaited because `handle_member` reads this only when needed let right = analysis_state.link_value(take(&mut *right), ImportAttributes::empty_ref()); @@ -1312,7 +1351,7 @@ async fn analyze_ecmascript_module_internal( .link_value(take(&mut *left), ImportAttributes::empty_ref()) .await?; - handle_in(&ast_path, right, left, &analysis_state, &mut analysis).await?; + handle_in(&ast_path, right, left, &analysis_state, &mut analysis, span).await?; } Effect::ImportedBinding { esm_reference_index, @@ -3411,34 +3450,40 @@ async fn handle_member<'a>( let has_member = state.free_var_references_members.contains_key(prop).await?; let is_prop_cache = prop == "cache"; - // This isn't pretty, but this avoids awaiting the future twice in the two branches below. - let obj = if has_member || is_prop_cache { - Some(link_obj.await?) - } else { - None - }; + let obj = link_obj.await?; + let obj_name = obj.get_definable_name(Some(&state.var_graph)); - if has_member { - let obj = obj.as_ref().unwrap(); - if let Some((mut name, false)) = obj.get_definable_name(Some(&state.var_graph)) { - name.0.push(DefinableNameSegmentRef::Name(prop)); - if let Some(value) = state - .compile_time_info_ref - .free_var_references - .get(&name) - .await? - { - handle_free_var_reference(ast_path, &value, span, state, analysis).await?; - return Ok(()); - } + if has_member && let Some((mut name, false)) = obj_name.clone() { + name.0.push(DefinableNameSegmentRef::Name(prop)); + if let Some(value) = state + .compile_time_info_ref + .free_var_references + .get(&name) + .await? + { + // Inline env var + handle_free_var_reference(ast_path, &value, span, state, analysis).await?; + return Ok(()); } } - if is_prop_cache - && let JsValue::WellKnownFunction(WellKnownFunctionKind::Require) = - obj.as_ref().unwrap() - { + if is_prop_cache && let JsValue::WellKnownFunction(WellKnownFunctionKind::Require) = &obj { analysis.add_code_gen(CjsRequireCacheAccess::new(ast_path.to_vec().into())); + return Ok(()); + } + + if let Some((name, false)) = &obj_name + && matches!( + name.0.as_slice(), + [ + DefinableNameSegmentRef::Name("process"), + DefinableNameSegmentRef::Name("env") + ] + ) + { + // non-inlined env var + analysis.add_runtime_env_var_reference(RcStr::from(prop)); + return Ok(()); } } @@ -3451,46 +3496,53 @@ async fn handle_in<'a>( left: JsValue<'a>, state: &AnalysisState<'a>, analysis: &mut AnalyzeEcmascriptModuleResultBuilder, + _span: Span, ) -> Result<()> { if let Some(left) = left.as_str() { let has_member = state.free_var_references_members.contains_key(left).await?; let is_left_cache = left == "cache"; - // This isn't pretty, but this avoids awaiting the future twice in the two branches below. - let right = if has_member || is_left_cache { - Some(link_right.await?) - } else { - None - }; + let right = link_right.await?; + let right_name = right.get_definable_name(Some(&state.var_graph)); - if has_member { - let right = right.as_ref().unwrap(); - if let Some((mut name, false)) = right.get_definable_name(Some(&state.var_graph)) { - name.0.push(DefinableNameSegmentRef::Name(left)); - if state - .compile_time_info_ref - .free_var_references - .get(&name) - .await? - .is_some() - { - analysis.add_code_gen(ConstantValueCodeGen::new( - CompileTimeDefineValue::Bool(true), - ast_path.to_vec().into(), - )); - return Ok(()); - } + if has_member && let Some((mut name, false)) = right_name.clone() { + name.0.push(DefinableNameSegmentRef::Name(left)); + if state + .compile_time_info_ref + .free_var_references + .get(&name) + .await? + .is_some() + { + analysis.add_code_gen(ConstantValueCodeGen::new( + CompileTimeDefineValue::Bool(true), + ast_path.to_vec().into(), + )); + return Ok(()); } } - if is_left_cache - && let JsValue::WellKnownFunction(WellKnownFunctionKind::Require) = - right.as_ref().unwrap() + if is_left_cache && let JsValue::WellKnownFunction(WellKnownFunctionKind::Require) = &right { analysis.add_code_gen(ConstantValueCodeGen::new( CompileTimeDefineValue::Bool(true), ast_path.to_vec().into(), )); + return Ok(()); + } + + if let Some((name, false)) = &right_name + && matches!( + name.0.as_slice(), + [ + DefinableNameSegmentRef::Name("process"), + DefinableNameSegmentRef::Name("env") + ] + ) + { + // non-inlined env var + analysis.add_runtime_env_var_reference(RcStr::from(left)); + return Ok(()); } } diff --git a/turbopack/crates/turbopack-ecmascript/src/references/tests.rs b/turbopack/crates/turbopack-ecmascript/src/references/tests.rs new file mode 100644 index 000000000000..5c79c0947823 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/src/references/tests.rs @@ -0,0 +1,140 @@ +use std::path::PathBuf; + +use anyhow::Result; +use swc_core::{ + self, + testing::{NormalizedOutput, fixture}, +}; +use turbo_rcstr::{RcStr, rcstr}; +use turbo_tasks::{ResolvedVc, TurboTasks, Vc}; +use turbo_tasks_backend::{BackendOptions, TurboTasksBackend, noop_backing_storage}; +use turbo_tasks_fs::{DiskFileSystem, FileSystem}; +use turbopack_core::{ + compile_time_info::CompileTimeInfo, + environment::{Environment, ExecutionEnvironment, NodeJsEnvironment}, + file_source::FileSource, + free_var_references, + ident::Layer, +}; +use turbopack_test_utils::noop_asset_context::NoopAssetContext; + +use crate::{ + AnalyzeMode, EcmascriptInputTransforms, EcmascriptModuleAsset, EcmascriptOptions, + references::analyze_ecmascript_module, +}; + +#[fixture("tests/references/**/input.js")] +fn fixture(input: PathBuf) { + let input = RcStr::from(input.to_str().unwrap()); + let rt = tokio::runtime::Builder::new_multi_thread() + .worker_threads(2) + .enable_all() + .build() + .unwrap(); + rt.block_on(async move { + let tt = TurboTasks::new(TurboTasksBackend::new( + BackendOptions::default(), + noop_backing_storage(), + )); + tt.run_once(async move { + fixture_op(input.clone(), AnalyzeMode::CodeGeneration) + .read_strongly_consistent() + .await?; + fixture_op(input.clone(), AnalyzeMode::Tracing) + .read_strongly_consistent() + .await?; + fixture_op(input, AnalyzeMode::CodeGenerationAndTracing) + .read_strongly_consistent() + .await?; + anyhow::Ok(()) + }) + .await + .unwrap(); + }); +} + +async fn setup( + root_dir: &str, + file: &str, + analyze_mode: AnalyzeMode, +) -> Result> { + let fs = DiskFileSystem::new(rcstr!("project"), Vc::cell(root_dir.into())); + + let environment = Environment::new(ExecutionEnvironment::NodeJsLambda( + NodeJsEnvironment::default().resolved_cell(), + )) + .to_resolved() + .await?; + let compile_time_info = CompileTimeInfo::builder(environment) + .free_var_references( + free_var_references!( + process.env.INLINED1 = "inlined1", + process.env.INLINED2 = "inlined2", + process.env.INLINED3 = "inlined3", + process.env.INLINED4 = "inlined4", + process.env.INLINED5 = "inlined5", + process.env.INLINED6 = "inlined6", + ) + .resolved_cell(), + ) + .cell() + .await? + .to_resolved() + .await?; + let layer = Layer::new(rcstr!("test")); + let module_asset_context = NoopAssetContext { + compile_time_info, + layer, + } + .resolved_cell(); + + let module = EcmascriptModuleAsset::builder( + ResolvedVc::upcast( + FileSource::new(fs.root().await?.join(file).unwrap()) + .to_resolved() + .await?, + ), + ResolvedVc::upcast(module_asset_context), + EcmascriptInputTransforms::empty().to_resolved().await?, + EcmascriptOptions { + follow_reexports: true, + analyze_mode, + ..Default::default() + } + .resolved_cell(), + compile_time_info, + None, + ) + .build() + .to_resolved() + .await?; + Ok(module) +} + +#[turbo_tasks::function(operation, root)] +async fn fixture_op(input: RcStr, analyze_mode: AnalyzeMode) -> anyhow::Result<()> { + let input = PathBuf::from(input.as_str()); + let module = setup( + input.parent().unwrap().to_str().unwrap(), + input.file_name().unwrap().to_str().unwrap(), + analyze_mode, + ) + .await?; + + let analysis = analyze_ecmascript_module(*module, None).await?; + + let env_var_info = analysis.env_var_info.await?; + + NormalizedOutput::from(format!("runtime: {:#?}", env_var_info.runtime)) + .compare_to_file(input.with_file_name(format!( + "env-vars{}.snapshot", + match analyze_mode { + AnalyzeMode::CodeGenerationAndTracing => "", + AnalyzeMode::CodeGeneration => ".codegen", + AnalyzeMode::Tracing => ".tracing", + } + ))) + .unwrap(); + + Ok(()) +} diff --git a/turbopack/crates/turbopack-ecmascript/src/rename/module.rs b/turbopack/crates/turbopack-ecmascript/src/rename/module.rs index 3cc85807fd43..ce5e5b7f0886 100644 --- a/turbopack/crates/turbopack-ecmascript/src/rename/module.rs +++ b/turbopack/crates/turbopack-ecmascript/src/rename/module.rs @@ -18,7 +18,7 @@ use turbopack_core::{ use crate::{ AnalyzeEcmascriptModuleResult, EcmascriptAnalyzable, EcmascriptAnalyzableExt, - EcmascriptModuleContent, EcmascriptModuleContentOptions, EcmascriptOptions, + EcmascriptModuleContent, EcmascriptModuleContentOptions, EcmascriptOptions, EnvVarInfo, MergedEcmascriptModule, SpecifiedModuleType, chunk::{ EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports, @@ -170,6 +170,11 @@ impl EcmascriptAnalyzable for EcmascriptModuleRenameModule { bail!("EcmascriptModuleRenameModule::analyze shouldn't be called"); } + #[turbo_tasks::function] + fn env_var_info(self: Vc) -> Vc { + EnvVarInfo::empty() + } + #[turbo_tasks::function] fn module_content_without_analysis( &self, diff --git a/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/facade/module.rs b/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/facade/module.rs index 0114a868f8d6..b320f17ababa 100644 --- a/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/facade/module.rs +++ b/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/facade/module.rs @@ -15,7 +15,7 @@ use turbopack_core::{ use crate::{ AnalyzeEcmascriptModuleResult, EcmascriptAnalyzable, EcmascriptAnalyzableExt, - EcmascriptModuleContent, EcmascriptModuleContentOptions, EcmascriptOptions, + EcmascriptModuleContent, EcmascriptModuleContentOptions, EcmascriptOptions, EnvVarInfo, MergedEcmascriptModule, SpecifiedModuleType, chunk::{ EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports, @@ -152,6 +152,11 @@ impl EcmascriptAnalyzable for EcmascriptModuleFacadeModule { bail!("EcmascriptModuleFacadeModule::analyze shouldn't be called"); } + #[turbo_tasks::function] + fn env_var_info(self: Vc) -> Vc { + EnvVarInfo::empty() + } + #[turbo_tasks::function] fn module_content_without_analysis( &self, diff --git a/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/locals/module.rs b/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/locals/module.rs index ac7320b27517..12e6f412e58c 100644 --- a/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/locals/module.rs +++ b/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/locals/module.rs @@ -17,7 +17,7 @@ use turbopack_core::{ use crate::{ AnalyzeEcmascriptModuleResult, EcmascriptAnalyzable, EcmascriptAnalyzableExt, EcmascriptModuleAsset, EcmascriptModuleContent, EcmascriptModuleContentOptions, - EcmascriptParsable, MergedEcmascriptModule, + EcmascriptParsable, EnvVarInfo, MergedEcmascriptModule, chunk::{ EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports, ecmascript_chunk_item, @@ -103,6 +103,11 @@ impl EcmascriptAnalyzable for EcmascriptModuleLocalsModule { self.module.analyze() } + #[turbo_tasks::function] + fn env_var_info(&self) -> Vc { + self.module.env_var_info() + } + #[turbo_tasks::function] fn module_content_without_analysis( &self, diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/graph-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/graph-effects.snapshot index 38aad4172f06..2ed61c961b14 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/graph-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/graph-effects.snapshot @@ -1,4 +1,18 @@ [ + DestructuredMember { + obj: Argument( + 105, + 0, + ), + prop: Constant( + Str( + Atom( + "value2", + ), + ), + ), + span: 108..114, + }, ImportedBinding { esm_reference_index: 1, export: Some( @@ -104,6 +118,20 @@ ), ], }, + DestructuredMember { + obj: Argument( + 39, + 0, + ), + prop: Constant( + Str( + Atom( + "value", + ), + ), + ), + span: 54..59, + }, ImportedBinding { esm_reference_index: 1, export: Some( diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/resolved-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/resolved-effects.snapshot index a5ca2867a488..68bda03f864f 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/resolved-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/resolved-effects.snapshot @@ -1,7 +1,7 @@ -0 -> 2 unreachable = ???*0* +0 -> 3 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 4 unreachable = ???*0* +0 -> 6 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/graph-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/graph-effects.snapshot index e963694b9d34..42b3e400e599 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/graph-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/graph-effects.snapshot @@ -354,6 +354,46 @@ ), ], }, + DestructuredMember { + obj: Call( + 2, + Variable( + ( + "pkgAndSubpathForCurrentPlatform", + #2, + ), + ), + [], + ), + prop: Constant( + Str( + Atom( + "pkg", + ), + ), + ), + span: 426..429, + }, + DestructuredMember { + obj: Call( + 2, + Variable( + ( + "pkgAndSubpathForCurrentPlatform", + #2, + ), + ), + [], + ), + prop: Constant( + Str( + Atom( + "subpath", + ), + ), + ), + span: 431..438, + }, Call { func: Variable( ( diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/resolved-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/resolved-effects.snapshot index 23c70802466e..d440fb01546f 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/resolved-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/resolved-effects.snapshot @@ -16,11 +16,11 @@ - *0* unreachable ⚠️ This value might have side effects -0 -> 9 call = (...) => {"pkg": pkg, "subpath": subpath}() +0 -> 11 call = (...) => {"pkg": pkg, "subpath": subpath}() -0 -> 11 free var = FreeVar(require) +0 -> 13 free var = FreeVar(require) -0 -> 12 member call = require*0*["resolve"]( +0 -> 14 member call = require*0*["resolve"]( `${(???*1* | "esbuild-windows-arm64" | "esbuild-windows-32" | "esbuild-windows-64" | ???*2* | ???*4*)}/${(???*5* | "esbuild.exe" | ???*6*)}` ) - *0* require: The require method from CommonJS @@ -39,6 +39,6 @@ - *6* unknown mutation ⚠️ This value might have side effects -0 -> 13 unreachable = ???*0* +0 -> 15 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/graph-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/graph-effects.snapshot index a994b0df6167..2e3f6cc34e16 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/graph-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/graph-effects.snapshot @@ -3473,6 +3473,46 @@ }, else: EffectsBlock { effects: [ + DestructuredMember { + obj: Call( + 2, + Variable( + ( + "pkgAndSubpathForCurrentPlatform", + #2, + ), + ), + [], + ), + prop: Constant( + Str( + Atom( + "pkg", + ), + ), + ), + span: 1513..1516, + }, + DestructuredMember { + obj: Call( + 2, + Variable( + ( + "pkgAndSubpathForCurrentPlatform", + #2, + ), + ), + [], + ), + prop: Constant( + Str( + Atom( + "subpath", + ), + ), + ), + span: 1518..1525, + }, Call { func: Variable( ( diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/resolved-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/resolved-effects.snapshot index c9fe95959fed..abe57c4d6bae 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/resolved-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/resolved-effects.snapshot @@ -142,11 +142,11 @@ - *0* unreachable ⚠️ This value might have side effects -44 -> 47 call = (...) => {"pkg": pkg, "subpath": subpath}() +44 -> 49 call = (...) => {"pkg": pkg, "subpath": subpath}() -44 -> 49 free var = FreeVar(require) +44 -> 51 free var = FreeVar(require) -44 -> 50 member call = require*0*["resolve"]( +44 -> 52 member call = require*0*["resolve"]( `${(???*1* | undefined | ???*2* | "esbuild-linux-64")}/${(???*3* | "esbuild.exe" | "bin/esbuild" | ???*4*)}` ) - *0* require: The require method from CommonJS @@ -159,9 +159,9 @@ - *4* unknown mutation ⚠️ This value might have side effects -44 -> 51 free var = FreeVar(downloadedBinPath) +44 -> 53 free var = FreeVar(downloadedBinPath) -44 -> 52 call = ???*0*( +44 -> 54 call = ???*0*( (???*1* | undefined | ???*2* | "esbuild-linux-64"), (???*3* | "esbuild.exe" | "bin/esbuild" | ???*4*) ) @@ -177,9 +177,9 @@ - *4* unknown mutation ⚠️ This value might have side effects -44 -> 54 free var = FreeVar(fs) +44 -> 56 free var = FreeVar(fs) -44 -> 55 member call = ???*0*["existsSync"]((???*1* | ???*2* | ???*8*)) +44 -> 57 member call = ???*0*["existsSync"]((???*1* | ???*2* | ???*8*)) - *0* FreeVar(fs) ⚠️ unknown global ⚠️ This value might have side effects @@ -206,7 +206,7 @@ ⚠️ unknown global ⚠️ This value might have side effects -44 -> 56 conditional = !(???*0*) +44 -> 58 conditional = !(???*0*) - *0* ???*1*["existsSync"](binPath) ⚠️ unknown callee object ⚠️ This value might have side effects @@ -214,18 +214,18 @@ ⚠️ unknown global ⚠️ This value might have side effects -56 -> 58 free var = FreeVar(require) +58 -> 60 free var = FreeVar(require) -56 -> 59 member call = require*0*["resolve"]((???*1* | undefined | ???*2* | "esbuild-linux-64")) +58 -> 61 member call = require*0*["resolve"]((???*1* | undefined | ???*2* | "esbuild-linux-64")) - *0* require: The require method from CommonJS - *1* pkg ⚠️ pattern without value - *2* unknown mutation ⚠️ This value might have side effects -56 -> 60 free var = FreeVar(Error) +58 -> 62 free var = FreeVar(Error) -56 -> 61 call = new ???*0*( +58 -> 63 call = new ???*0*( `The package "${(???*1* | undefined | ???*2* | "esbuild-linux-64")}" could not be found, and is needed by esbuild. If you are installing esbuild with npm, make sure that you don't specify the @@ -240,29 +240,29 @@ by esbuild to install the correct binary executable for your current platform.` - *2* unknown mutation ⚠️ This value might have side effects -44 -> 62 free var = FreeVar(require) +44 -> 64 free var = FreeVar(require) -44 -> 63 call = require*0*("pnpapi") +44 -> 65 call = require*0*("pnpapi") - *0* require: The require method from CommonJS -44 -> 64 conditional = (false | true) +44 -> 66 conditional = (false | true) -64 -> 67 free var = FreeVar(require) +66 -> 69 free var = FreeVar(require) -64 -> 68 member call = require*0*["resolve"]("esbuild") +66 -> 70 member call = require*0*["resolve"]("esbuild") - *0* require: The require method from CommonJS -64 -> 69 member call = path*0*["dirname"]("\"esbuild\"/resolved/lib/index.js") +66 -> 71 member call = path*0*["dirname"]("\"esbuild\"/resolved/lib/index.js") - *0* path: The Node.js path module: https://nodejs.org/api/path.html -64 -> 72 member call = path*0*["basename"]((???*1* | "esbuild.exe" | "bin/esbuild" | ???*2*)) +66 -> 74 member call = path*0*["basename"]((???*1* | "esbuild.exe" | "bin/esbuild" | ???*2*)) - *0* path: The Node.js path module: https://nodejs.org/api/path.html - *1* subpath ⚠️ pattern without value - *2* unknown mutation ⚠️ This value might have side effects -64 -> 73 member call = path*0*["join"]( +66 -> 75 member call = path*0*["join"]( "\"esbuild\"/resolved/lib", `pnpapi-${(???*1* | undefined | ???*2* | "esbuild-linux-64")}-${???*3*}` ) @@ -283,9 +283,9 @@ by esbuild to install the correct binary executable for your current platform.` - *7* unknown mutation ⚠️ This value might have side effects -64 -> 75 free var = FreeVar(fs) +66 -> 77 free var = FreeVar(fs) -64 -> 76 member call = ???*0*["existsSync"]( +66 -> 78 member call = ???*0*["existsSync"]( `"esbuild"/resolved/lib${("/" | "")}pnpapi-${(???*1* | undefined | ???*2* | "esbuild-linux-64")}-${???*3*}` ) - *0* FreeVar(fs) @@ -307,7 +307,7 @@ by esbuild to install the correct binary executable for your current platform.` - *7* unknown mutation ⚠️ This value might have side effects -64 -> 77 conditional = !(???*0*) +66 -> 79 conditional = !(???*0*) - *0* ???*1*["existsSync"](binTargetPath) ⚠️ unknown callee object ⚠️ This value might have side effects @@ -315,9 +315,9 @@ by esbuild to install the correct binary executable for your current platform.` ⚠️ unknown global ⚠️ This value might have side effects -77 -> 79 free var = FreeVar(fs) +79 -> 81 free var = FreeVar(fs) -77 -> 80 member call = ???*0*["copyFileSync"]( +79 -> 82 member call = ???*0*["copyFileSync"]( (???*1* | ???*2* | ???*8*), `"esbuild"/resolved/lib${("/" | "")}pnpapi-${(???*10* | undefined | ???*11* | "esbuild-linux-64")}-${???*12*}` ) @@ -364,9 +364,9 @@ by esbuild to install the correct binary executable for your current platform.` - *16* unknown mutation ⚠️ This value might have side effects -77 -> 82 free var = FreeVar(fs) +79 -> 84 free var = FreeVar(fs) -77 -> 83 member call = ???*0*["chmodSync"]( +79 -> 85 member call = ???*0*["chmodSync"]( `"esbuild"/resolved/lib${("/" | "")}pnpapi-${(???*1* | undefined | ???*2* | "esbuild-linux-64")}-${???*3*}`, 493 ) @@ -389,10 +389,10 @@ by esbuild to install the correct binary executable for your current platform.` - *7* unknown mutation ⚠️ This value might have side effects -64 -> 84 unreachable = ???*0* +66 -> 86 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -64 -> 85 unreachable = ???*0* +66 -> 87 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/object/graph-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/object/graph-effects.snapshot index 8b20cd2ca5cb..2183c922b2a5 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/object/graph-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/object/graph-effects.snapshot @@ -515,6 +515,134 @@ ], span: 392..407, }, + DestructuredMember { + obj: Variable( + ( + "object", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "a", + ), + ), + ), + span: 437..438, + }, + DestructuredMember { + obj: Variable( + ( + "object", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "b", + ), + ), + ), + span: 444..447, + }, + DestructuredMember { + obj: Variable( + ( + "object", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "c", + ), + ), + ), + span: 453..458, + }, + DestructuredMember { + obj: Variable( + ( + "object", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "d", + ), + ), + ), + span: 464..465, + }, + DestructuredMember { + obj: Variable( + ( + "object", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "a", + ), + ), + ), + span: 490..491, + }, + DestructuredMember { + obj: Variable( + ( + "object", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "b", + ), + ), + ), + span: 493..494, + }, + DestructuredMember { + obj: Variable( + ( + "object", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "c", + ), + ), + ), + span: 496..497, + }, + DestructuredMember { + obj: Variable( + ( + "object", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "d", + ), + ), + ), + span: 499..500, + }, FreeVar { var: "global", ast_path: [ diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/object/resolved-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/object/resolved-effects.snapshot index 3ff470ad60d4..d8c8ba757562 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/object/resolved-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/object/resolved-effects.snapshot @@ -1,5 +1,5 @@ -0 -> 13 free var = FreeVar(global) +0 -> 21 free var = FreeVar(global) -0 -> 17 free var = FreeVar(global) +0 -> 25 free var = FreeVar(global) -0 -> 18 free var = FreeVar(global) +0 -> 26 free var = FreeVar(global) diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph-explained.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph-explained.snapshot index b997be27668b..6722136c5c64 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph-explained.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph-explained.snapshot @@ -18,9 +18,7 @@ metrics = ((clientComponentLoadTimes === 0) ? undefined : { "clientComponentLoadTimes": clientComponentLoadTimes }) -options = ???*0* -- *0* options - ⚠️ pattern without value +options = (arguments[0] | {}) startTime = FreeVar(performance)["now"]() diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph.snapshot index f26b33c2c4d1..d8dde91cd44e 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph.snapshot @@ -136,17 +136,20 @@ ), ( "options", - Unknown { - original_value: Some( - Variable( - ( - "options", - #7, - ), + Alternatives { + total_nodes: 3, + values: [ + Argument( + 415, + 0, ), - ), - reason: "pattern without value", - has_side_effects: false, + Object { + total_nodes: 1, + parts: [], + mutability: Mutable, + }, + ], + logical_property: None, }, ), ( diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/resolved-explained.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/resolved-explained.snapshot index 4bb8c5f12f0a..414252f95ae1 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/resolved-explained.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/resolved-explained.snapshot @@ -34,9 +34,9 @@ metrics = (???*0* ? undefined : {"clientComponentLoadTimes": (0 | ???*4*)}) - *6* unsupported expression ⚠️ This value might have side effects -options = ???*0* -- *0* options - ⚠️ pattern without value +options = (???*0* | {}) +- *0* arguments[0] + ⚠️ function calls are not analyzed yet startTime = ???*0*() - *0* ???*1*["now"] diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2521/graph-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2521/graph-effects.snapshot index 163e411ce11d..6d23f991fc75 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2521/graph-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2521/graph-effects.snapshot @@ -1,4 +1,29 @@ [ + DestructuredMember { + obj: Call( + 3, + FreeVar( + "require", + ), + [ + Constant( + Str( + Atom( + "./libvips", + ), + ), + ), + ], + ), + prop: Constant( + Str( + Atom( + "runtimePlatformArch", + ), + ), + ), + span: 9..28, + }, FreeVar { var: "require", ast_path: [ diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2521/resolved-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2521/resolved-effects.snapshot index d84dfc985d3a..886c5a7f8832 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2521/resolved-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2521/resolved-effects.snapshot @@ -1,20 +1,20 @@ -0 -> 1 free var = FreeVar(require) +0 -> 2 free var = FreeVar(require) -0 -> 2 call = require*0*("./libvips") +0 -> 3 call = require*0*("./libvips") - *0* require: The require method from CommonJS -0 -> 3 call = module<./libvips, {}>["runtimePlatformArch"]() +0 -> 4 call = module<./libvips, {}>["runtimePlatformArch"]() -0 -> 5 free var = FreeVar(console) +0 -> 6 free var = FreeVar(console) -0 -> 6 member call = ???*0*["log"]("runtimePlatform:", module<./libvips, {}>["runtimePlatformArch"]()) +0 -> 7 member call = ???*0*["log"]("runtimePlatform:", module<./libvips, {}>["runtimePlatformArch"]()) - *0* FreeVar(console) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 7 free var = FreeVar(require) +0 -> 8 free var = FreeVar(require) -0 -> 8 call = require*0*( +0 -> 9 call = require*0*( ( | `../src/build/Release/sharp-${???*1*}.node` | "../src/build/Release/sharp-wasm32.node" @@ -31,6 +31,6 @@ - *3* unknown mutation ⚠️ This value might have side effects -0 -> 10 member call = []["push"](???*0*) +0 -> 11 member call = []["push"](???*0*) - *0* err ⚠️ pattern without value diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/graph-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/graph-effects.snapshot index fbc1ab3bef7d..e0241621a969 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/graph-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/graph-effects.snapshot @@ -1,4 +1,18 @@ [ + DestructuredMember { + obj: Argument( + 24, + 0, + ), + prop: Constant( + Str( + Atom( + "variable", + ), + ), + ), + span: 27..35, + }, Member { obj: FreeVar( "Math", diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/resolved-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/resolved-effects.snapshot index aa385a0d5164..cd493c70005f 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/resolved-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/resolved-effects.snapshot @@ -1,19 +1,19 @@ -0 -> 2 free var = FreeVar(Math) +0 -> 3 free var = FreeVar(Math) -0 -> 3 member call = ???*0*["random"]() +0 -> 4 member call = ???*0*["random"]() - *0* FreeVar(Math) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 5 free var = FreeVar(JSON) +0 -> 6 free var = FreeVar(JSON) -0 -> 6 conditional = ((???*0* | "true") === "true") +0 -> 7 conditional = ((???*0* | "true") === "true") - *0* ???*1*["variable"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 7 member call = ???*0*["stringify"]( +0 -> 8 member call = ???*0*["stringify"]( { "condition": ((???*1* | "true") === "true"), "buggedConditionalCheck": (???*3* ? "true" : "false") @@ -33,11 +33,11 @@ - *5* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 8 unreachable = ???*0* +0 -> 9 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 9 call = (...) => FreeVar(JSON)["stringify"]( +0 -> 10 call = (...) => FreeVar(JSON)["stringify"]( { "condition": (variable === "true"), "buggedConditionalCheck": ((variable === "true") ? "true" : "false") diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/path-join/graph-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/path-join/graph-effects.snapshot index 823af389c32e..9835d4f85083 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/path-join/graph-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/path-join/graph-effects.snapshot @@ -1164,6 +1164,34 @@ ], span: 514..519, }, + DestructuredMember { + obj: Awaited( + 4, + Call( + 3, + FreeVar( + "import", + ), + [ + Constant( + Str( + Atom( + "path", + ), + ), + ), + ], + ), + ), + prop: Constant( + Str( + Atom( + "join", + ), + ), + ), + span: 529..533, + }, DynamicImport { args: [ Value( diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/path-join/resolved-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/path-join/resolved-effects.snapshot index f88c3721aaed..e34d2df8b5a6 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/path-join/resolved-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/path-join/resolved-effects.snapshot @@ -33,4 +33,4 @@ 0 -> 17 call = require*0*("path") - *0* require: The require method from CommonJS -0 -> 22 dynamic import = FreeVar(import)("path") +0 -> 23 dynamic import = FreeVar(import)("path") diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pattern-assignment/graph-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pattern-assignment/graph-effects.snapshot index fe51488c7066..a8d1b41d9905 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pattern-assignment/graph-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/pattern-assignment/graph-effects.snapshot @@ -1 +1,154 @@ -[] +[ + DestructuredMember { + obj: Object { + total_nodes: 3, + parts: [ + KeyValue( + Constant( + Str( + Atom( + "singleAssignBool", + ), + ), + ), + Constant( + True, + ), + ), + ], + mutability: Mutable, + }, + prop: Constant( + Str( + Atom( + "singleAssignBool", + ), + ), + ), + span: 9..25, + }, + DestructuredMember { + obj: Object { + total_nodes: 3, + parts: [ + KeyValue( + Constant( + Str( + Atom( + "objPatternBool", + ), + ), + ), + Constant( + True, + ), + ), + ], + mutability: Mutable, + }, + prop: Constant( + Str( + Atom( + "objPatternBool", + ), + ), + ), + span: 65..79, + }, + DestructuredMember { + obj: Object { + total_nodes: 3, + parts: [ + KeyValue( + Constant( + Str( + Atom( + "objPatternBool", + ), + ), + ), + Constant( + False, + ), + ), + ], + mutability: Mutable, + }, + prop: Constant( + Str( + Atom( + "objPatternBool", + ), + ), + ), + span: 113..127, + }, + DestructuredMember { + obj: Object { + total_nodes: 4, + parts: [ + KeyValue( + Constant( + Str( + Atom( + "inner", + ), + ), + ), + Array { + total_nodes: 2, + items: [ + Constant( + True, + ), + ], + mutable: true, + }, + ), + ], + mutability: Mutable, + }, + prop: Constant( + Str( + Atom( + "inner", + ), + ), + ), + span: 231..236, + }, + DestructuredMember { + obj: Object { + total_nodes: 4, + parts: [ + KeyValue( + Constant( + Str( + Atom( + "inner", + ), + ), + ), + Array { + total_nodes: 2, + items: [ + Constant( + False, + ), + ], + mutable: true, + }, + ), + ], + mutability: Mutable, + }, + prop: Constant( + Str( + Atom( + "inner", + ), + ), + ), + span: 287..292, + }, +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/peg/resolved-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/peg/resolved-effects.snapshot index 94ef16268542..9f4471dce5eb 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/peg/resolved-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/peg/resolved-effects.snapshot @@ -971,83 +971,83 @@ - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 290 unreachable = ???*0* +0 -> 292 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 291 unreachable = ???*0* +0 -> 293 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 292 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("?", false) +0 -> 294 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("?", false) -0 -> 293 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(":", false) +0 -> 295 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(":", false) -0 -> 294 unreachable = ???*0* +0 -> 296 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 295 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("??", false) +0 -> 297 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("??", false) -0 -> 296 call = (...) => tail["reduce"](*arrow function 169161*, head)(???*0*, ???*1*) +0 -> 298 call = (...) => tail["reduce"](*arrow function 169161*, head)(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* arguments[1] ⚠️ function calls are not analyzed yet -0 -> 297 unreachable = ???*0* +0 -> 299 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 298 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("=", false) +0 -> 300 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("=", false) -0 -> 299 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("!=", false) +0 -> 301 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("!=", false) -0 -> 300 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<>", false) +0 -> 302 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<>", false) -0 -> 301 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<=", false) +0 -> 303 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<=", false) -0 -> 302 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">=", false) +0 -> 304 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">=", false) -0 -> 303 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<", false) +0 -> 305 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<", false) -0 -> 304 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">", false) +0 -> 306 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">", false) -0 -> 305 unreachable = ???*0* +0 -> 307 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 306 unreachable = ???*0* +0 -> 308 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 307 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("|", false) +0 -> 309 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("|", false) -0 -> 308 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("^", false) +0 -> 310 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("^", false) -0 -> 309 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("&", false) +0 -> 311 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("&", false) -0 -> 310 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<<", false) +0 -> 312 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<<", false) -0 -> 311 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">>>", false) +0 -> 313 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">>>", false) -0 -> 312 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">>", false) +0 -> 314 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">>", false) -0 -> 313 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("||", false) +0 -> 315 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("||", false) -0 -> 314 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("/", false) +0 -> 316 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("/", false) -0 -> 315 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("%", false) +0 -> 317 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("%", false) -0 -> 316 unreachable = ???*0* +0 -> 318 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 317 unreachable = ???*0* +0 -> 319 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 319 member call = ???*0*["reduce"]( +0 -> 321 member call = ???*0*["reduce"]( (...) => { "type": "collection_member_expression", "object": object, @@ -1061,23 +1061,23 @@ - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 320 unreachable = ???*0* +0 -> 324 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 321 unreachable = ???*0* +0 -> 325 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 322 unreachable = ???*0* +0 -> 326 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 323 free var = FreeVar(Number) +0 -> 327 free var = FreeVar(Number) -0 -> 324 call = (...) => input["substring"](peg$savedPos, peg$currPos)() +0 -> 328 call = (...) => input["substring"](peg$savedPos, peg$currPos)() -0 -> 325 call = ???*0*(???*1*) +0 -> 329 call = ???*0*(???*1*) - *0* FreeVar(Number) ⚠️ unknown global ⚠️ This value might have side effects @@ -1086,23 +1086,23 @@ - *2* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 326 unreachable = ???*0* +0 -> 330 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 327 conditional = ???*0* +0 -> 331 conditional = ???*0* - *0* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 328 unreachable = ???*0* +0 -> 332 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 329 unreachable = ???*0* +0 -> 333 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 331 conditional = "startRule" in (???*0* | ???*1*) +0 -> 335 conditional = "startRule" in (???*0* | ???*1*) - *0* arguments[1] ⚠️ function calls are not analyzed yet - *1* (???*2* ? ???*4* : {}) @@ -1114,7 +1114,7 @@ - *4* options ⚠️ circular variable reference -331 -> 334 conditional = !(???*0*) +335 -> 338 conditional = !(???*0*) - *0* ???*1* in {"sql": (...) => s0} ⚠️ nested operation - *1* ???*2*["startRule"] @@ -1122,9 +1122,9 @@ - *2* arguments[1] ⚠️ function calls are not analyzed yet -334 -> 335 free var = FreeVar(Error) +338 -> 339 free var = FreeVar(Error) -334 -> 337 call = new ???*0*(`Can't start parsing from rule "${???*1*}".`) +338 -> 341 call = new ???*0*(`Can't start parsing from rule "${???*1*}".`) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects @@ -1133,7 +1133,7 @@ - *2* arguments[1] ⚠️ function calls are not analyzed yet -0 -> 341 member call = ???*0*["substring"](???*1*, ???*2*) +0 -> 345 member call = ???*0*["substring"](???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached @@ -1141,11 +1141,11 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 342 unreachable = ???*0* +0 -> 346 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 343 call = (...) => { +0 -> 347 call = (...) => { "start": {"offset": startPos, "line": startPosDetails["line"], "column": startPosDetails["column"]}, "end": {"offset": endPos, "line": endPosDetails["line"], "column": endPosDetails["column"]} }(???*0*, ???*1*) @@ -1154,15 +1154,15 @@ - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 344 unreachable = ???*0* +0 -> 348 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 345 conditional = (???*0* !== undefined) +0 -> 349 conditional = (???*0* !== undefined) - *0* max number of linking steps reached ⚠️ This value might have side effects -345 -> 346 call = (...) => { +349 -> 350 call = (...) => { "start": {"offset": startPos, "line": startPosDetails["line"], "column": startPosDetails["column"]}, "end": {"offset": endPos, "line": endPosDetails["line"], "column": endPosDetails["column"]} }(???*0*, ???*1*) @@ -1171,11 +1171,11 @@ - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 347 call = (...) => {"type": "other", "description": description}(???*0*) +0 -> 351 call = (...) => {"type": "other", "description": description}(???*0*) - *0* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 349 member call = ???*0*["substring"](???*1*, ???*2*) +0 -> 353 member call = ???*0*["substring"](???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached @@ -1183,7 +1183,7 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 350 call = (...) => new peg$SyntaxError(peg$SyntaxError["buildMessage"](expected, found), expected, found, location)([{"type": "other", "description": ???*0*}], ???*1*, ???*3*) +0 -> 354 call = (...) => new peg$SyntaxError(peg$SyntaxError["buildMessage"](expected, found), expected, found, location)([{"type": "other", "description": ???*0*}], ???*1*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* ???*2*["substring"](peg$savedPos, peg$currPos) @@ -1193,11 +1193,11 @@ - *3* max number of linking steps reached ⚠️ This value might have side effects -0 -> 351 conditional = (???*0* !== undefined) +0 -> 355 conditional = (???*0* !== undefined) - *0* max number of linking steps reached ⚠️ This value might have side effects -351 -> 352 call = (...) => { +355 -> 356 call = (...) => { "start": {"offset": startPos, "line": startPosDetails["line"], "column": startPosDetails["column"]}, "end": {"offset": endPos, "line": endPosDetails["line"], "column": endPosDetails["column"]} }(???*0*, ???*1*) @@ -1206,33 +1206,33 @@ - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 353 call = (...) => new peg$SyntaxError(message, null, null, location)(???*0*, ???*1*) +0 -> 357 call = (...) => new peg$SyntaxError(message, null, null, location)(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 354 unreachable = ???*0* +0 -> 358 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 355 unreachable = ???*0* +0 -> 359 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 356 unreachable = ???*0* +0 -> 360 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 357 unreachable = ???*0* +0 -> 361 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 358 unreachable = ???*0* +0 -> 362 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 360 conditional = ({"line": 1, "column": 1} | ???*0* | {"line": ???*2*, "column": ???*4*}) +0 -> 364 conditional = ({"line": 1, "column": 1} | ???*0* | {"line": ???*2*, "column": ???*4*}) - *0* [][???*1*] ⚠️ unknown array prototype methods or values - *1* arguments[0] @@ -1246,11 +1246,11 @@ - *5* details ⚠️ circular variable reference -360 -> 361 unreachable = ???*0* +364 -> 365 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -360 -> 367 member call = ???*0*["charCodeAt"]((???*1* | ???*2* | ???*3*)) +364 -> 371 member call = ???*0*["charCodeAt"]((???*1* | ???*2* | ???*3*)) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* p @@ -1260,57 +1260,57 @@ - *3* updated with update expression ⚠️ This value might have side effects -360 -> 368 conditional = (???*0* === 10) +364 -> 372 conditional = (???*0* === 10) - *0* ???*1*["charCodeAt"](p) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -360 -> 373 unreachable = ???*0* +364 -> 377 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 374 unreachable = ???*0* +0 -> 378 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 375 call = (...) => details(???*0*) +0 -> 379 call = (...) => details(???*0*) - *0* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 376 call = (...) => details(???*0*) +0 -> 380 call = (...) => details(???*0*) - *0* arguments[1] ⚠️ function calls are not analyzed yet -0 -> 381 unreachable = ???*0* +0 -> 385 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 382 unreachable = ???*0* +0 -> 386 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 384 member call = []["push"](???*0*) +0 -> 388 member call = []["push"](???*0*) - *0* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 385 call = new (...) => undefined(???*0*, null, null, ???*1*) +0 -> 389 call = new (...) => undefined(???*0*, null, null, ???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* arguments[1] ⚠️ function calls are not analyzed yet -0 -> 386 unreachable = ???*0* +0 -> 390 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 388 member call = (...) => undefined["buildMessage"](???*0*, ???*1*) +0 -> 392 member call = (...) => undefined["buildMessage"](???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* arguments[1] ⚠️ function calls are not analyzed yet -0 -> 389 call = new (...) => undefined((...) => undefined["buildMessage"](???*0*, ???*1*), ???*2*, ???*3*, ???*4*) +0 -> 393 call = new (...) => undefined((...) => undefined["buildMessage"](???*0*, ???*1*), ???*2*, ???*3*, ???*4*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* arguments[1] @@ -1322,71 +1322,57 @@ - *4* arguments[2] ⚠️ function calls are not analyzed yet -0 -> 390 unreachable = ???*0* +0 -> 394 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 391 call = (...) => s0() +0 -> 395 call = (...) => s0() -0 -> 392 conditional = (???*0* !== {}) +0 -> 396 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -392 -> 393 call = (...) => s0() +396 -> 397 call = (...) => s0() -392 -> 394 conditional = (???*0* !== {}) +396 -> 398 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -394 -> 395 call = (...) => s0() +398 -> 399 call = (...) => s0() -394 -> 396 conditional = ((???*0* | []) !== {}) +398 -> 400 conditional = ((???*0* | []) !== {}) - *0* s3 ⚠️ pattern without value -396 -> 397 call = (...) => {"type": "sql", "body": body}(???*0*) +400 -> 401 call = (...) => {"type": "sql", "body": body}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 398 unreachable = ???*0* +0 -> 402 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 399 call = (...) => s0() +0 -> 403 call = (...) => s0() -0 -> 400 conditional = (???*0* !== {}) +0 -> 404 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -400 -> 401 call = (...) => s0() +404 -> 405 call = (...) => s0() -400 -> 402 conditional = ((???*0* | []) !== {}) +404 -> 406 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -402 -> 403 call = (...) => s0() - -402 -> 404 conditional = (???*0* !== {}) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -404 -> 405 call = (...) => s0() - -404 -> 406 conditional = (???*0* !== {}) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - 406 -> 407 call = (...) => s0() 406 -> 408 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -408 -> 409 call = (...) => v(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +408 -> 409 call = (...) => s0() -402 -> 410 conditional = (???*0* !== {}) +408 -> 410 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects @@ -1396,9 +1382,11 @@ - *0* max number of linking steps reached ⚠️ This value might have side effects -412 -> 413 call = (...) => s0() +412 -> 413 call = (...) => v(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -412 -> 414 conditional = (???*0* !== {}) +406 -> 414 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects @@ -1426,15 +1414,9 @@ - *0* max number of linking steps reached ⚠️ This value might have side effects -422 -> 423 call = (...) => v(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects +422 -> 423 call = (...) => s0() -416 -> 424 conditional = (???*0* !== {}) +422 -> 424 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects @@ -1444,9 +1426,15 @@ - *0* max number of linking steps reached ⚠️ This value might have side effects -426 -> 427 call = (...) => s0() +426 -> 427 call = (...) => v(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* max number of linking steps reached + ⚠️ This value might have side effects -426 -> 428 conditional = (???*0* !== {}) +420 -> 428 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects @@ -1462,7 +1450,19 @@ - *0* max number of linking steps reached ⚠️ This value might have side effects -432 -> 433 call = (...) => v(???*0*, ???*1*, ???*2*, ???*3*) +432 -> 433 call = (...) => s0() + +432 -> 434 conditional = (???*0* !== {}) +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +434 -> 435 call = (...) => s0() + +434 -> 436 conditional = (???*0* !== {}) +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +436 -> 437 call = (...) => v(???*0*, ???*1*, ???*2*, ???*3*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1472,47 +1472,47 @@ - *3* max number of linking steps reached ⚠️ This value might have side effects -426 -> 434 conditional = (???*0* !== {}) +430 -> 438 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -434 -> 435 call = (...) => s0() +438 -> 439 call = (...) => s0() -434 -> 436 conditional = (???*0* !== {}) +438 -> 440 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -436 -> 437 call = (...) => s0() +440 -> 441 call = (...) => s0() -436 -> 438 conditional = (???*0* !== {}) +440 -> 442 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -438 -> 439 call = (...) => s0() +442 -> 443 call = (...) => s0() -438 -> 440 conditional = ((???*0* | []) !== {}) +442 -> 444 conditional = ((???*0* | []) !== {}) - *0* s13 ⚠️ pattern without value -440 -> 441 call = (...) => s0() +444 -> 445 call = (...) => s0() -440 -> 442 conditional = (???*0* !== {}) +444 -> 446 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -442 -> 443 call = (...) => s0() +446 -> 447 call = (...) => s0() -442 -> 444 conditional = ((???*0* | []) !== {}) +446 -> 448 conditional = ((???*0* | []) !== {}) - *0* s15 ⚠️ pattern without value -444 -> 445 call = (...) => s0() +448 -> 449 call = (...) => s0() -444 -> 446 conditional = (???*0* !== {}) +448 -> 450 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -446 -> 447 call = (...) => v(???*0*, ???*1*, ???*2*, ???*3*, ???*4*) +450 -> 451 call = (...) => v(???*0*, ???*1*, ???*2*, ???*3*, ???*4*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1524,11 +1524,11 @@ - *4* max number of linking steps reached ⚠️ This value might have side effects -436 -> 448 conditional = (???*0* !== {}) +440 -> 452 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -448 -> 449 call = (...) => { +452 -> 453 call = (...) => { "type": "select_query", "top": top, "select": select, @@ -1547,193 +1547,193 @@ - *4* max number of linking steps reached ⚠️ This value might have side effects -0 -> 450 unreachable = ???*0* +0 -> 454 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 452 member call = ???*0*["charCodeAt"](???*1*) +0 -> 456 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 453 conditional = (???*0* === 42) +0 -> 457 conditional = (???*0* === 42) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -453 -> 454 conditional = ((0 | ???*0*) === 0) +457 -> 458 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -454 -> 455 call = (...) => undefined( +458 -> 459 call = (...) => undefined( {"type": "literal", "text": "*", "ignoreCase": false} ) -0 -> 456 conditional = (???*0* !== {}) +0 -> 460 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -456 -> 457 call = (...) => {"type": "select_specification", "*": true}() +460 -> 461 call = (...) => {"type": "select_specification", "*": true}() -0 -> 458 conditional = (???*0* === {}) +0 -> 462 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -458 -> 459 call = (...) => s0() +462 -> 463 call = (...) => s0() -458 -> 460 conditional = (???*0* !== {}) +462 -> 464 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -460 -> 461 call = (...) => {"type": "select_specification", "properties": properties}(???*0*) +464 -> 465 call = (...) => {"type": "select_specification", "properties": properties}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -458 -> 462 conditional = (???*0* === {}) +462 -> 466 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -462 -> 463 call = (...) => s0() +466 -> 467 call = (...) => s0() -462 -> 464 conditional = (???*0* !== {}) +466 -> 468 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -464 -> 465 call = (...) => s0() +468 -> 469 call = (...) => s0() -464 -> 466 conditional = ((???*0* | []) !== {}) +468 -> 470 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -466 -> 467 call = (...) => s0() +470 -> 471 call = (...) => s0() -466 -> 468 conditional = (???*0* !== {}) +470 -> 472 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -468 -> 469 call = (...) => {"type": "select_specification", "value": value}(???*0*) +472 -> 473 call = (...) => {"type": "select_specification", "value": value}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 470 unreachable = ???*0* +0 -> 474 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 471 call = (...) => s0() +0 -> 475 call = (...) => s0() -0 -> 472 conditional = (???*0* !== {}) +0 -> 476 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -472 -> 473 call = (...) => s0() +476 -> 477 call = (...) => s0() -472 -> 474 conditional = (???*0* !== {}) +476 -> 478 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -474 -> 476 member call = ???*0*["charCodeAt"](???*1*) +478 -> 480 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -474 -> 477 conditional = (???*0* === 44) +478 -> 481 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -477 -> 478 conditional = ((0 | ???*0*) === 0) +481 -> 482 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -478 -> 479 call = (...) => undefined( +482 -> 483 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -474 -> 480 conditional = ((???*0* | "," | {}) !== {}) +478 -> 484 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -480 -> 481 call = (...) => s0() +484 -> 485 call = (...) => s0() -480 -> 482 conditional = ((???*0* | []) !== {}) +484 -> 486 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -482 -> 483 call = (...) => s0() +486 -> 487 call = (...) => s0() -482 -> 484 conditional = (???*0* !== {}) +486 -> 488 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -484 -> 485 call = (...) => v(???*0*, ???*1*) +488 -> 489 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -472 -> 487 member call = (???*0* | [])["push"](???*1*) +476 -> 491 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -472 -> 488 call = (...) => s0() +476 -> 492 call = (...) => s0() -472 -> 489 conditional = (???*0* !== {}) +476 -> 493 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -489 -> 491 member call = ???*0*["charCodeAt"](???*1*) +493 -> 495 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -489 -> 492 conditional = (???*0* === 44) +493 -> 496 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -492 -> 493 conditional = ((0 | ???*0*) === 0) +496 -> 497 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -493 -> 494 call = (...) => undefined( +497 -> 498 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -489 -> 495 conditional = ((???*0* | "," | {}) !== {}) +493 -> 499 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -495 -> 496 call = (...) => s0() +499 -> 500 call = (...) => s0() -495 -> 497 conditional = ((???*0* | []) !== {}) +499 -> 501 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -497 -> 498 call = (...) => s0() +501 -> 502 call = (...) => s0() -497 -> 499 conditional = (???*0* !== {}) +501 -> 503 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -499 -> 500 call = (...) => v(???*0*, ???*1*) +503 -> 504 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -472 -> 501 conditional = ((???*0* | []) !== {}) +476 -> 505 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -501 -> 502 call = (...) => {"type": "object_property_list", "properties": ???*0*}(???*1*, (???*2* | [])) +505 -> 506 call = (...) => {"type": "object_property_list", "properties": ???*0*}(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1741,331 +1741,331 @@ - *2* s2 ⚠️ pattern without value -0 -> 503 unreachable = ???*0* +0 -> 507 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 504 call = (...) => s0() +0 -> 508 call = (...) => s0() -0 -> 505 conditional = (???*0* !== {}) +0 -> 509 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -505 -> 506 call = (...) => s0() +509 -> 510 call = (...) => s0() -505 -> 507 conditional = (???*0* !== {}) +509 -> 511 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -507 -> 508 call = (...) => s0() +511 -> 512 call = (...) => s0() -507 -> 509 conditional = (???*0* !== {}) +511 -> 513 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -509 -> 510 call = (...) => s0() +513 -> 514 call = (...) => s0() -509 -> 511 conditional = ((???*0* | []) !== {}) +513 -> 515 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -511 -> 512 call = (...) => s0() +515 -> 516 call = (...) => s0() -511 -> 513 conditional = (???*0* !== {}) +515 -> 517 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -513 -> 514 call = (...) => v(???*0*, ???*1*) +517 -> 518 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -505 -> 516 member call = (???*0* | [])["push"](???*1*) +509 -> 520 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -505 -> 517 call = (...) => s0() +509 -> 521 call = (...) => s0() -505 -> 518 conditional = (???*0* !== {}) +509 -> 522 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -518 -> 519 call = (...) => s0() +522 -> 523 call = (...) => s0() -518 -> 520 conditional = (???*0* !== {}) +522 -> 524 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -520 -> 521 call = (...) => s0() +524 -> 525 call = (...) => s0() -520 -> 522 conditional = ((???*0* | []) !== {}) +524 -> 526 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -522 -> 523 call = (...) => s0() +526 -> 527 call = (...) => s0() -522 -> 524 conditional = (???*0* !== {}) +526 -> 528 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -524 -> 525 call = (...) => v(???*0*, ???*1*) +528 -> 529 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -505 -> 526 conditional = ((???*0* | []) !== {}) +509 -> 530 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -526 -> 527 call = (...) => {"type": "from_specification", "source": source, "joins": joins}(???*0*, (???*1* | [])) +530 -> 531 call = (...) => {"type": "from_specification", "source": source, "joins": joins}(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 528 unreachable = ???*0* +0 -> 532 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 529 call = (...) => s0() +0 -> 533 call = (...) => s0() -0 -> 530 conditional = (???*0* !== {}) +0 -> 534 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -530 -> 531 call = (...) => s0() +534 -> 535 call = (...) => s0() -530 -> 532 conditional = (???*0* !== {}) +534 -> 536 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -532 -> 533 call = (...) => s0() +536 -> 537 call = (...) => s0() -532 -> 534 conditional = (???*0* !== {}) +536 -> 538 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -534 -> 535 call = (...) => s0() +538 -> 539 call = (...) => s0() -534 -> 536 conditional = (???*0* !== {}) +538 -> 540 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -536 -> 537 call = (...) => s0() +540 -> 541 call = (...) => s0() -536 -> 538 conditional = (???*0* !== {}) +540 -> 542 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -538 -> 539 call = (...) => {"type": "from_source", "expression": expression, "alias": alias, "iteration": true}(???*0*, ???*1*) +542 -> 543 call = (...) => {"type": "from_source", "expression": expression, "alias": alias, "iteration": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 540 conditional = (???*0* === {}) +0 -> 544 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -540 -> 541 call = (...) => s0() +544 -> 545 call = (...) => s0() -540 -> 542 conditional = (???*0* !== {}) +544 -> 546 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -542 -> 543 call = (...) => s0() +546 -> 547 call = (...) => s0() -542 -> 544 conditional = (???*0* !== {}) +546 -> 548 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -544 -> 545 call = (...) => s0() +548 -> 549 call = (...) => s0() -542 -> 546 conditional = (???*0* !== {}) +546 -> 550 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -546 -> 547 call = (...) => s0() +550 -> 551 call = (...) => s0() -546 -> 548 conditional = (???*0* !== {}) +550 -> 552 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -548 -> 549 call = (...) => s0() +552 -> 553 call = (...) => s0() -548 -> 550 conditional = (???*0* !== {}) +552 -> 554 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -550 -> 551 call = (...) => v(???*0*, ???*1*) +554 -> 555 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -542 -> 552 conditional = (???*0* !== {}) +546 -> 556 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -552 -> 553 call = (...) => {"type": "from_source", "expression": expression, "alias": alias}(???*0*, ???*1*) +556 -> 557 call = (...) => {"type": "from_source", "expression": expression, "alias": alias}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 554 unreachable = ???*0* +0 -> 558 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 555 call = (...) => s0() +0 -> 559 call = (...) => s0() -0 -> 556 conditional = (???*0* === {}) +0 -> 560 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -556 -> 557 call = (...) => s0() +560 -> 561 call = (...) => s0() -556 -> 558 conditional = (???*0* === {}) +560 -> 562 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -558 -> 559 call = (...) => s0() +562 -> 563 call = (...) => s0() -0 -> 560 unreachable = ???*0* +0 -> 564 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 561 call = (...) => s0() +0 -> 565 call = (...) => s0() -0 -> 562 conditional = (???*0* !== {}) +0 -> 566 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -562 -> 563 call = (...) => {"type": "filter_condition", "condition": condition}(???*0*) +566 -> 567 call = (...) => {"type": "filter_condition", "condition": condition}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 564 unreachable = ???*0* +0 -> 568 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 565 call = (...) => s0() +0 -> 569 call = (...) => s0() -0 -> 566 conditional = (???*0* !== {}) +0 -> 570 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -566 -> 567 call = (...) => s0() +570 -> 571 call = (...) => s0() -566 -> 568 conditional = (???*0* !== {}) +570 -> 572 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -568 -> 570 member call = ???*0*["charCodeAt"](???*1*) +572 -> 574 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -568 -> 571 conditional = (???*0* === 44) +572 -> 575 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -571 -> 572 conditional = ((0 | ???*0*) === 0) +575 -> 576 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -572 -> 573 call = (...) => undefined( +576 -> 577 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -568 -> 574 conditional = ((???*0* | "," | {}) !== {}) +572 -> 578 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -574 -> 575 call = (...) => s0() +578 -> 579 call = (...) => s0() -574 -> 576 conditional = ((???*0* | []) !== {}) +578 -> 580 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -576 -> 577 call = (...) => s0() +580 -> 581 call = (...) => s0() -576 -> 578 conditional = (???*0* !== {}) +580 -> 582 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -578 -> 579 call = (...) => v(???*0*, ???*1*) +582 -> 583 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -566 -> 581 member call = (???*0* | [])["push"](???*1*) +570 -> 585 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -566 -> 582 call = (...) => s0() +570 -> 586 call = (...) => s0() -566 -> 583 conditional = (???*0* !== {}) +570 -> 587 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -583 -> 585 member call = ???*0*["charCodeAt"](???*1*) +587 -> 589 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -583 -> 586 conditional = (???*0* === 44) +587 -> 590 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -586 -> 587 conditional = ((0 | ???*0*) === 0) +590 -> 591 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -587 -> 588 call = (...) => undefined( +591 -> 592 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -583 -> 589 conditional = ((???*0* | "," | {}) !== {}) +587 -> 593 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -589 -> 590 call = (...) => s0() +593 -> 594 call = (...) => s0() -589 -> 591 conditional = ((???*0* | []) !== {}) +593 -> 595 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -591 -> 592 call = (...) => s0() +595 -> 596 call = (...) => s0() -591 -> 593 conditional = (???*0* !== {}) +595 -> 597 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -593 -> 594 call = (...) => v(???*0*, ???*1*) +597 -> 598 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -566 -> 595 conditional = ((???*0* | []) !== {}) +570 -> 599 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -595 -> 596 call = (...) => {"type": "sort_specification", "expressions": ???*0*}(???*1*, (???*2* | [])) +599 -> 600 call = (...) => {"type": "sort_specification", "expressions": ???*0*}(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -2073,445 +2073,445 @@ - *2* s2 ⚠️ pattern without value -0 -> 597 unreachable = ???*0* +0 -> 601 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 598 call = (...) => s0() +0 -> 602 call = (...) => s0() -0 -> 599 conditional = (???*0* !== {}) +0 -> 603 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -599 -> 600 call = (...) => s0() +603 -> 604 call = (...) => s0() -599 -> 601 conditional = (???*0* !== {}) +603 -> 605 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -601 -> 602 call = (...) => s0() +605 -> 606 call = (...) => s0() -601 -> 603 conditional = (???*0* === {}) +605 -> 607 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -603 -> 604 call = (...) => s0() +607 -> 608 call = (...) => s0() -601 -> 605 conditional = (???*0* !== {}) +605 -> 609 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -605 -> 606 call = (...) => v(???*0*, ???*1*) +609 -> 610 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -599 -> 607 conditional = (???*0* !== {}) +603 -> 611 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -607 -> 608 call = (...) => {"type": "sort_expression", "expression": expression, "order": order}(???*0*, ???*1*) +611 -> 612 call = (...) => {"type": "sort_expression", "expression": expression, "order": order}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 609 unreachable = ???*0* +0 -> 613 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 610 call = (...) => s0() +0 -> 614 call = (...) => s0() -0 -> 611 conditional = (???*0* !== {}) +0 -> 615 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -611 -> 612 call = (...) => s0() +615 -> 616 call = (...) => s0() -611 -> 613 conditional = ((???*0* | []) !== {}) +615 -> 617 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -613 -> 615 member call = ???*0*["charCodeAt"](???*1*) +617 -> 619 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -613 -> 616 conditional = (???*0* === 46) +617 -> 620 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -616 -> 617 conditional = ((0 | ???*0*) === 0) +620 -> 621 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -617 -> 618 call = (...) => undefined( +621 -> 622 call = (...) => undefined( {"type": "literal", "text": ".", "ignoreCase": false} ) -613 -> 619 conditional = ((???*0* | "." | {} | "(") !== {}) +617 -> 623 conditional = ((???*0* | "." | {} | "(") !== {}) - *0* s3 ⚠️ pattern without value -619 -> 620 call = (...) => s0() +623 -> 624 call = (...) => s0() -619 -> 621 conditional = ((???*0* | []) !== {}) +623 -> 625 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -621 -> 622 call = (...) => s0() +625 -> 626 call = (...) => s0() -621 -> 623 conditional = (???*0* !== {}) +625 -> 627 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -623 -> 624 call = (...) => s0() +627 -> 628 call = (...) => s0() -623 -> 625 conditional = ((???*0* | []) !== {}) +627 -> 629 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -625 -> 627 member call = ???*0*["charCodeAt"](???*1*) +629 -> 631 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -625 -> 628 conditional = (???*0* === 40) +629 -> 632 conditional = (???*0* === 40) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -628 -> 629 conditional = ((0 | ???*0*) === 0) +632 -> 633 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -629 -> 630 call = (...) => undefined( +633 -> 634 call = (...) => undefined( {"type": "literal", "text": "(", "ignoreCase": false} ) -625 -> 631 conditional = ((???*0* | "(" | {} | ")") !== {}) +629 -> 635 conditional = ((???*0* | "(" | {} | ")") !== {}) - *0* s7 ⚠️ pattern without value -631 -> 632 call = (...) => s0() +635 -> 636 call = (...) => s0() -631 -> 633 conditional = ((???*0* | []) !== {}) +635 -> 637 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -633 -> 634 call = (...) => s0() +637 -> 638 call = (...) => s0() -633 -> 635 conditional = (???*0* !== {}) +637 -> 639 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -635 -> 636 call = (...) => s0() +639 -> 640 call = (...) => s0() -635 -> 637 conditional = ((???*0* | []) !== {}) +639 -> 641 conditional = ((???*0* | []) !== {}) - *0* s10 ⚠️ pattern without value -637 -> 639 member call = ???*0*["charCodeAt"](???*1*) +641 -> 643 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -637 -> 640 conditional = (???*0* === 41) +641 -> 644 conditional = (???*0* === 41) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -640 -> 641 conditional = ((0 | ???*0*) === 0) +644 -> 645 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -641 -> 642 call = (...) => undefined( +645 -> 646 call = (...) => undefined( {"type": "literal", "text": ")", "ignoreCase": false} ) -637 -> 643 conditional = ((???*0* | ")" | {}) !== {}) +641 -> 647 conditional = ((???*0* | ")" | {}) !== {}) - *0* s11 ⚠️ pattern without value -643 -> 644 call = (...) => {"type": "scalar_function_expression", "name": name, "arguments": args, "udf": true}(???*0*, ???*1*) +647 -> 648 call = (...) => {"type": "scalar_function_expression", "name": name, "arguments": args, "udf": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 645 conditional = (???*0* === {}) +0 -> 649 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -645 -> 646 call = (...) => s0() +649 -> 650 call = (...) => s0() -645 -> 647 conditional = (???*0* !== {}) +649 -> 651 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -647 -> 648 call = (...) => s0() +651 -> 652 call = (...) => s0() -647 -> 649 conditional = ((???*0* | []) !== {}) +651 -> 653 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -649 -> 651 member call = ???*0*["charCodeAt"](???*1*) +653 -> 655 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -649 -> 652 conditional = (???*0* === 40) +653 -> 656 conditional = (???*0* === 40) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -652 -> 653 conditional = ((0 | ???*0*) === 0) +656 -> 657 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -653 -> 654 call = (...) => undefined( +657 -> 658 call = (...) => undefined( {"type": "literal", "text": "(", "ignoreCase": false} ) -649 -> 655 conditional = ((???*0* | "." | {} | "(") !== {}) +653 -> 659 conditional = ((???*0* | "." | {} | "(") !== {}) - *0* s3 ⚠️ pattern without value -655 -> 656 call = (...) => s0() +659 -> 660 call = (...) => s0() -655 -> 657 conditional = ((???*0* | []) !== {}) +659 -> 661 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -657 -> 658 call = (...) => s0() +661 -> 662 call = (...) => s0() -657 -> 659 conditional = (???*0* !== {}) +661 -> 663 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -659 -> 660 call = (...) => s0() +663 -> 664 call = (...) => s0() -659 -> 661 conditional = ((???*0* | []) !== {}) +663 -> 665 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -661 -> 663 member call = ???*0*["charCodeAt"](???*1*) +665 -> 667 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -661 -> 664 conditional = (???*0* === 41) +665 -> 668 conditional = (???*0* === 41) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -664 -> 665 conditional = ((0 | ???*0*) === 0) +668 -> 669 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -665 -> 666 call = (...) => undefined( +669 -> 670 call = (...) => undefined( {"type": "literal", "text": ")", "ignoreCase": false} ) -661 -> 667 conditional = ((???*0* | "(" | {} | ")") !== {}) +665 -> 671 conditional = ((???*0* | "(" | {} | ")") !== {}) - *0* s7 ⚠️ pattern without value -667 -> 668 call = (...) => {"type": "scalar_function_expression", "name": name, "arguments": args}(???*0*, ???*1*) +671 -> 672 call = (...) => {"type": "scalar_function_expression", "name": name, "arguments": args}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 669 unreachable = ???*0* +0 -> 673 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 671 member call = ???*0*["charCodeAt"](???*1*) +0 -> 675 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 672 conditional = (???*0* === 123) +0 -> 676 conditional = (???*0* === 123) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -672 -> 673 conditional = ((0 | ???*0*) === 0) +676 -> 677 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -673 -> 674 call = (...) => undefined( +677 -> 678 call = (...) => undefined( {"type": "literal", "text": "{", "ignoreCase": false} ) -0 -> 675 conditional = (???*0* !== {}) +0 -> 679 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -675 -> 676 call = (...) => s0() +679 -> 680 call = (...) => s0() -675 -> 677 conditional = ((???*0* | []) !== {}) +679 -> 681 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -677 -> 678 call = (...) => s0() +681 -> 682 call = (...) => s0() -677 -> 679 conditional = (???*0* !== {}) +681 -> 683 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -679 -> 680 call = (...) => s0() +683 -> 684 call = (...) => s0() -679 -> 681 conditional = (???*0* !== {}) +683 -> 685 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -681 -> 683 member call = ???*0*["charCodeAt"](???*1*) +685 -> 687 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -681 -> 684 conditional = (???*0* === 44) +685 -> 688 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -684 -> 685 conditional = ((0 | ???*0*) === 0) +688 -> 689 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -685 -> 686 call = (...) => undefined( +689 -> 690 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -681 -> 687 conditional = ((???*0* | "," | {}) !== {}) +685 -> 691 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -687 -> 688 call = (...) => s0() +691 -> 692 call = (...) => s0() -687 -> 689 conditional = ((???*0* | []) !== {}) +691 -> 693 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -689 -> 690 call = (...) => s0() +693 -> 694 call = (...) => s0() -689 -> 691 conditional = (???*0* !== {}) +693 -> 695 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -691 -> 692 call = (...) => v(???*0*, ???*1*) +695 -> 696 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -679 -> 694 member call = (???*0* | [])["push"](???*1*) +683 -> 698 member call = (???*0* | [])["push"](???*1*) - *0* s4 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -679 -> 695 call = (...) => s0() +683 -> 699 call = (...) => s0() -679 -> 696 conditional = (???*0* !== {}) +683 -> 700 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -696 -> 698 member call = ???*0*["charCodeAt"](???*1*) +700 -> 702 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -696 -> 699 conditional = (???*0* === 44) +700 -> 703 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -699 -> 700 conditional = ((0 | ???*0*) === 0) +703 -> 704 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -700 -> 701 call = (...) => undefined( +704 -> 705 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -696 -> 702 conditional = ((???*0* | "," | {}) !== {}) +700 -> 706 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -702 -> 703 call = (...) => s0() +706 -> 707 call = (...) => s0() -702 -> 704 conditional = ((???*0* | []) !== {}) +706 -> 708 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -704 -> 705 call = (...) => s0() +708 -> 709 call = (...) => s0() -704 -> 706 conditional = (???*0* !== {}) +708 -> 710 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -706 -> 707 call = (...) => v(???*0*, ???*1*) +710 -> 711 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -679 -> 708 conditional = ((???*0* | []) !== {}) +683 -> 712 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -708 -> 709 call = (...) => s0() +712 -> 713 call = (...) => s0() -708 -> 710 conditional = (???*0* !== {}) +712 -> 714 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -710 -> 712 member call = ???*0*["charCodeAt"](???*1*) +714 -> 716 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -710 -> 713 conditional = (???*0* === 125) +714 -> 717 conditional = (???*0* === 125) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -713 -> 714 conditional = ((0 | ???*0*) === 0) +717 -> 718 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -714 -> 715 call = (...) => undefined( +718 -> 719 call = (...) => undefined( {"type": "literal", "text": "}", "ignoreCase": false} ) -710 -> 716 conditional = (???*0* !== {}) +714 -> 720 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -716 -> 717 call = (...) => {"type": "scalar_object_expression", "properties": (head ? ???*0* : [])}(???*1*, (???*2* | [])) +720 -> 721 call = (...) => {"type": "scalar_object_expression", "properties": (head ? ???*0* : [])}(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -2519,213 +2519,213 @@ - *2* s4 ⚠️ pattern without value -0 -> 718 unreachable = ???*0* +0 -> 722 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 720 member call = ???*0*["charCodeAt"](???*1*) +0 -> 724 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 721 conditional = (???*0* === 91) +0 -> 725 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -721 -> 722 conditional = ((0 | ???*0*) === 0) +725 -> 726 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -722 -> 723 call = (...) => undefined( +726 -> 727 call = (...) => undefined( {"type": "literal", "text": "[", "ignoreCase": false} ) -0 -> 724 conditional = (???*0* !== {}) +0 -> 728 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -724 -> 725 call = (...) => s0() +728 -> 729 call = (...) => s0() -724 -> 726 conditional = ((???*0* | []) !== {}) +728 -> 730 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -726 -> 727 call = (...) => s0() +730 -> 731 call = (...) => s0() -726 -> 728 conditional = (???*0* !== {}) +730 -> 732 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -728 -> 729 call = (...) => s0() +732 -> 733 call = (...) => s0() -728 -> 730 conditional = ((???*0* | []) !== {}) +732 -> 734 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -730 -> 732 member call = ???*0*["charCodeAt"](???*1*) +734 -> 736 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -730 -> 733 conditional = (???*0* === 93) +734 -> 737 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -733 -> 734 conditional = ((0 | ???*0*) === 0) +737 -> 738 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -734 -> 735 call = (...) => undefined( +738 -> 739 call = (...) => undefined( {"type": "literal", "text": "]", "ignoreCase": false} ) -730 -> 736 conditional = ((???*0* | "]" | {}) !== {}) +734 -> 740 conditional = ((???*0* | "]" | {}) !== {}) - *0* s5 ⚠️ pattern without value -736 -> 737 call = (...) => {"type": "scalar_array_expression", "elements": elements}(???*0*) +740 -> 741 call = (...) => {"type": "scalar_array_expression", "elements": elements}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 738 unreachable = ???*0* +0 -> 742 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 739 call = (...) => s0() +0 -> 743 call = (...) => s0() -0 -> 740 conditional = (???*0* === {}) +0 -> 744 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -740 -> 741 call = (...) => s0() +744 -> 745 call = (...) => s0() -740 -> 742 conditional = (???*0* === {}) +744 -> 746 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -742 -> 743 call = (...) => s0() +746 -> 747 call = (...) => s0() -742 -> 744 conditional = (???*0* === {}) +746 -> 748 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -744 -> 745 call = (...) => s0() +748 -> 749 call = (...) => s0() -744 -> 746 conditional = (???*0* === {}) +748 -> 750 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -746 -> 747 call = (...) => s0() +750 -> 751 call = (...) => s0() -746 -> 748 conditional = (???*0* === {}) +750 -> 752 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -748 -> 749 call = (...) => s0() +752 -> 753 call = (...) => s0() -748 -> 750 conditional = (???*0* === {}) +752 -> 754 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -750 -> 751 call = (...) => s0() +754 -> 755 call = (...) => s0() -0 -> 752 unreachable = ???*0* +0 -> 756 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 754 member call = ???*0*["substr"](???*1*, 9) +0 -> 758 member call = ???*0*["substr"](???*1*, 9) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 755 conditional = (???*0* === "undefined") +0 -> 759 conditional = (???*0* === "undefined") - *0* ???*1*["substr"](peg$currPos, 9) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -755 -> 756 conditional = ((0 | ???*0*) === 0) +759 -> 760 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -756 -> 757 call = (...) => undefined( +760 -> 761 call = (...) => undefined( {"type": "literal", "text": "undefined", "ignoreCase": false} ) -0 -> 758 conditional = ((???*0* | "undefined" | {} | {"type": "undefined_constant"}) !== {}) +0 -> 762 conditional = ((???*0* | "undefined" | {} | {"type": "undefined_constant"}) !== {}) - *0* s1 ⚠️ pattern without value -758 -> 759 call = (...) => {"type": "undefined_constant"}() +762 -> 763 call = (...) => {"type": "undefined_constant"}() -0 -> 760 unreachable = ???*0* +0 -> 764 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 761 call = (...) => s0() +0 -> 765 call = (...) => s0() -0 -> 762 conditional = (???*0* !== {}) +0 -> 766 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -762 -> 763 call = (...) => {"type": "null_constant"}() +766 -> 767 call = (...) => {"type": "null_constant"}() -0 -> 764 unreachable = ???*0* +0 -> 768 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 765 call = (...) => s0() +0 -> 769 call = (...) => s0() -0 -> 766 conditional = (???*0* !== {}) +0 -> 770 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -766 -> 767 call = (...) => {"type": "boolean_constant", "value": false}() +770 -> 771 call = (...) => {"type": "boolean_constant", "value": false}() -0 -> 768 conditional = (???*0* === {}) +0 -> 772 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -768 -> 769 call = (...) => s0() +772 -> 773 call = (...) => s0() -768 -> 770 conditional = (???*0* !== {}) +772 -> 774 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -770 -> 771 call = (...) => {"type": "boolean_constant", "value": true}() +774 -> 775 call = (...) => {"type": "boolean_constant", "value": true}() -0 -> 772 unreachable = ???*0* +0 -> 776 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 774 member call = ???*0*["charCodeAt"](???*1*) +0 -> 778 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 775 conditional = (???*0* === 45) +0 -> 779 conditional = (???*0* === 45) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -775 -> 776 conditional = ((0 | ???*0*) === 0) +779 -> 780 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -776 -> 777 call = (...) => undefined( +780 -> 781 call = (...) => undefined( {"type": "literal", "text": "-", "ignoreCase": false} ) -0 -> 778 conditional = ((???*0* | "-" | {} | null | {"type": "number_constant", "value": ???*1*}) !== {}) +0 -> 782 conditional = ((???*0* | "-" | {} | null | {"type": "number_constant", "value": ???*1*}) !== {}) - *0* s1 ⚠️ pattern without value - *1* ((???*2* | "0x" | {} | null) ? ???*3* : ???*5*) @@ -2745,129 +2745,129 @@ ⚠️ unknown global ⚠️ This value might have side effects -778 -> 780 member call = ???*0*["substr"](???*1*, 2) +782 -> 784 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -778 -> 781 conditional = (???*0* === "0x") +782 -> 785 conditional = (???*0* === "0x") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -781 -> 782 conditional = ((0 | ???*0*) === 0) +785 -> 786 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -782 -> 783 call = (...) => undefined( +786 -> 787 call = (...) => undefined( {"type": "literal", "text": "0x", "ignoreCase": false} ) -778 -> 784 conditional = ((???*0* | "0x" | {} | null) !== {}) +782 -> 788 conditional = ((???*0* | "0x" | {} | null) !== {}) - *0* s2 ⚠️ pattern without value -784 -> 787 member call = ???*0*["charAt"](???*1*) +788 -> 791 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -784 -> 788 member call = /^[0-9]/["test"](???*0*) +788 -> 792 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -784 -> 789 conditional = /^[0-9]/["test"](???*0*) +788 -> 793 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -789 -> 791 member call = ???*0*["charAt"](???*1*) +793 -> 795 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -789 -> 792 conditional = ((0 | ???*0*) === 0) +793 -> 796 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -792 -> 793 call = (...) => undefined( +796 -> 797 call = (...) => undefined( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -784 -> 794 conditional = (???*0* !== {}) +788 -> 798 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -794 -> 796 member call = (???*0* | [] | {})["push"](???*1*) +798 -> 800 member call = (???*0* | [] | {})["push"](???*1*) - *0* s3 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -794 -> 799 member call = ???*0*["charAt"](???*1*) +798 -> 803 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -794 -> 800 member call = /^[0-9]/["test"](???*0*) +798 -> 804 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -794 -> 801 conditional = /^[0-9]/["test"](???*0*) +798 -> 805 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -801 -> 803 member call = ???*0*["charAt"](???*1*) +805 -> 807 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -801 -> 804 conditional = ((0 | ???*0*) === 0) +805 -> 808 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -804 -> 805 call = (...) => undefined( +808 -> 809 call = (...) => undefined( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -784 -> 806 conditional = ((???*0* | [] | {}) !== {}) +788 -> 810 conditional = ((???*0* | [] | {}) !== {}) - *0* s3 ⚠️ pattern without value -806 -> 808 member call = ???*0*["charCodeAt"](???*1*) +810 -> 812 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -806 -> 809 conditional = (???*0* === 46) +810 -> 813 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -809 -> 810 conditional = ((0 | ???*0*) === 0) +813 -> 814 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -810 -> 811 call = (...) => undefined( +814 -> 815 call = (...) => undefined( {"type": "literal", "text": ".", "ignoreCase": false} ) -806 -> 812 conditional = ((???*0* | "." | {} | [???*1*, (???*2* | [] | {})]) !== {}) +810 -> 816 conditional = ((???*0* | "." | {} | [???*1*, (???*2* | [] | {})]) !== {}) - *0* s5 ⚠️ pattern without value - *1* s5 @@ -2875,39 +2875,39 @@ - *2* s6 ⚠️ pattern without value -812 -> 815 member call = ???*0*["charAt"](???*1*) +816 -> 819 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -812 -> 816 member call = /^[0-9]/["test"](???*0*) +816 -> 820 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -812 -> 817 conditional = /^[0-9]/["test"](???*0*) +816 -> 821 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -817 -> 819 member call = ???*0*["charAt"](???*1*) +821 -> 823 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -817 -> 820 conditional = ((0 | ???*0*) === 0) +821 -> 824 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -820 -> 821 call = (...) => undefined( +824 -> 825 call = (...) => undefined( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -812 -> 822 conditional = ((???*0* | ???*1* | {}) !== {}) +816 -> 826 conditional = ((???*0* | ???*1* | {}) !== {}) - *0* s7 ⚠️ pattern without value - *1* ???*2*["charAt"](peg$currPos) @@ -2915,7 +2915,7 @@ - *2* arguments[0] ⚠️ function calls are not analyzed yet -822 -> 824 member call = (???*0* | [] | {})["push"]((???*1* | ???*2* | {})) +826 -> 828 member call = (???*0* | [] | {})["push"]((???*1* | ???*2* | {})) - *0* s6 ⚠️ pattern without value - *1* s7 @@ -2925,74 +2925,74 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -822 -> 827 member call = ???*0*["charAt"](???*1*) +826 -> 831 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -822 -> 828 member call = /^[0-9]/["test"](???*0*) +826 -> 832 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -822 -> 829 conditional = /^[0-9]/["test"](???*0*) +826 -> 833 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -829 -> 831 member call = ???*0*["charAt"](???*1*) +833 -> 835 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -829 -> 832 conditional = ((0 | ???*0*) === 0) +833 -> 836 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -832 -> 833 call = (...) => undefined( +836 -> 837 call = (...) => undefined( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -806 -> 834 conditional = (???*0* !== {}) +810 -> 838 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -834 -> 835 call = (...) => { +838 -> 839 call = (...) => { "type": "number_constant", "value": (hex ? FreeVar(parseInt)(text(), 16) : FreeVar(parseFloat)(text())) }((???*0* | "0x" | {} | null)) - *0* s2 ⚠️ pattern without value -0 -> 836 unreachable = ???*0* +0 -> 840 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 838 member call = ???*0*["charCodeAt"](???*1*) +0 -> 842 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 839 conditional = (???*0* === 34) +0 -> 843 conditional = (???*0* === 34) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -839 -> 840 conditional = ((0 | ???*0*) === 0) +843 -> 844 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -840 -> 841 call = (...) => undefined( +844 -> 845 call = (...) => undefined( {"type": "literal", "text": "\"", "ignoreCase": false} ) -0 -> 842 conditional = (( +0 -> 846 conditional = (( | ???*0* | "\"" | {} @@ -3010,73 +3010,73 @@ - *4* []["join"] ⚠️ non-num constant property on array -842 -> 843 call = (...) => s0() +846 -> 847 call = (...) => s0() -842 -> 845 member call = (???*0* | [])["push"](???*1*) +846 -> 849 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -842 -> 846 call = (...) => s0() +846 -> 850 call = (...) => s0() -842 -> 847 conditional = ((???*0* | []) !== {}) +846 -> 851 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -847 -> 849 member call = ???*0*["charCodeAt"](???*1*) +851 -> 853 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -847 -> 850 conditional = (???*0* === 34) +851 -> 854 conditional = (???*0* === 34) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -850 -> 851 conditional = ((0 | ???*0*) === 0) +854 -> 855 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -851 -> 852 call = (...) => undefined( +855 -> 856 call = (...) => undefined( {"type": "literal", "text": "\"", "ignoreCase": false} ) -847 -> 853 conditional = (???*0* !== {}) +851 -> 857 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -853 -> 854 call = (...) => {"type": "string_constant", "value": chars["join"]("")}((???*0* | [])) +857 -> 858 call = (...) => {"type": "string_constant", "value": chars["join"]("")}((???*0* | [])) - *0* s2 ⚠️ pattern without value -0 -> 855 conditional = (???*0* === {}) +0 -> 859 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -855 -> 857 member call = ???*0*["charCodeAt"](???*1*) +859 -> 861 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -855 -> 858 conditional = (???*0* === 39) +859 -> 862 conditional = (???*0* === 39) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -858 -> 859 conditional = ((0 | ???*0*) === 0) +862 -> 863 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -859 -> 860 call = (...) => undefined( +863 -> 864 call = (...) => undefined( {"type": "literal", "text": "'", "ignoreCase": false} ) -855 -> 861 conditional = (( +859 -> 865 conditional = (( | ???*0* | "\"" | {} @@ -3094,225 +3094,225 @@ - *4* []["join"] ⚠️ non-num constant property on array -861 -> 862 call = (...) => s0() +865 -> 866 call = (...) => s0() -861 -> 864 member call = (???*0* | [])["push"](???*1*) +865 -> 868 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -861 -> 865 call = (...) => s0() +865 -> 869 call = (...) => s0() -861 -> 866 conditional = ((???*0* | []) !== {}) +865 -> 870 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -866 -> 868 member call = ???*0*["charCodeAt"](???*1*) +870 -> 872 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -866 -> 869 conditional = (???*0* === 39) +870 -> 873 conditional = (???*0* === 39) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -869 -> 870 conditional = ((0 | ???*0*) === 0) +873 -> 874 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -870 -> 871 call = (...) => undefined( +874 -> 875 call = (...) => undefined( {"type": "literal", "text": "'", "ignoreCase": false} ) -866 -> 872 conditional = (???*0* !== {}) +870 -> 876 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -872 -> 873 call = (...) => {"type": "string_constant", "value": chars["join"]("")}((???*0* | [])) +876 -> 877 call = (...) => {"type": "string_constant", "value": chars["join"]("")}((???*0* | [])) - *0* s2 ⚠️ pattern without value -0 -> 874 unreachable = ???*0* +0 -> 878 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 876 member call = ???*0*["charCodeAt"](???*1*) +0 -> 880 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 877 conditional = (???*0* === 91) +0 -> 881 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -877 -> 878 conditional = ((0 | ???*0*) === 0) +881 -> 882 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -878 -> 879 call = (...) => undefined( +882 -> 883 call = (...) => undefined( {"type": "literal", "text": "[", "ignoreCase": false} ) -0 -> 880 conditional = (???*0* !== {}) +0 -> 884 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -880 -> 881 call = (...) => s0() +884 -> 885 call = (...) => s0() -880 -> 882 conditional = ((???*0* | []) !== {}) +884 -> 886 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -882 -> 883 call = (...) => s0() +886 -> 887 call = (...) => s0() -882 -> 884 conditional = (???*0* !== {}) +886 -> 888 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -884 -> 885 call = (...) => s0() +888 -> 889 call = (...) => s0() -884 -> 886 conditional = (???*0* !== {}) +888 -> 890 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -886 -> 888 member call = ???*0*["charCodeAt"](???*1*) +890 -> 892 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -886 -> 889 conditional = (???*0* === 44) +890 -> 893 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -889 -> 890 conditional = ((0 | ???*0*) === 0) +893 -> 894 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -890 -> 891 call = (...) => undefined( +894 -> 895 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -886 -> 892 conditional = ((???*0* | "," | {}) !== {}) +890 -> 896 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -892 -> 893 call = (...) => s0() +896 -> 897 call = (...) => s0() -892 -> 894 conditional = ((???*0* | []) !== {}) +896 -> 898 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -894 -> 895 call = (...) => s0() +898 -> 899 call = (...) => s0() -894 -> 896 conditional = (???*0* !== {}) +898 -> 900 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -896 -> 897 call = (...) => v(???*0*, ???*1*) +900 -> 901 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -884 -> 899 member call = (???*0* | [])["push"](???*1*) +888 -> 903 member call = (???*0* | [])["push"](???*1*) - *0* s4 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -884 -> 900 call = (...) => s0() +888 -> 904 call = (...) => s0() -884 -> 901 conditional = (???*0* !== {}) +888 -> 905 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -901 -> 903 member call = ???*0*["charCodeAt"](???*1*) +905 -> 907 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -901 -> 904 conditional = (???*0* === 44) +905 -> 908 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -904 -> 905 conditional = ((0 | ???*0*) === 0) +908 -> 909 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -905 -> 906 call = (...) => undefined( +909 -> 910 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -901 -> 907 conditional = ((???*0* | "," | {}) !== {}) +905 -> 911 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -907 -> 908 call = (...) => s0() +911 -> 912 call = (...) => s0() -907 -> 909 conditional = ((???*0* | []) !== {}) +911 -> 913 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -909 -> 910 call = (...) => s0() +913 -> 914 call = (...) => s0() -909 -> 911 conditional = (???*0* !== {}) +913 -> 915 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -911 -> 912 call = (...) => v(???*0*, ???*1*) +915 -> 916 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -884 -> 913 conditional = ((???*0* | []) !== {}) +888 -> 917 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -913 -> 914 call = (...) => s0() +917 -> 918 call = (...) => s0() -913 -> 915 conditional = (???*0* !== {}) +917 -> 919 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -915 -> 917 member call = ???*0*["charCodeAt"](???*1*) +919 -> 921 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -915 -> 918 conditional = (???*0* === 93) +919 -> 922 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -918 -> 919 conditional = ((0 | ???*0*) === 0) +922 -> 923 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -919 -> 920 call = (...) => undefined( +923 -> 924 call = (...) => undefined( {"type": "literal", "text": "]", "ignoreCase": false} ) -915 -> 921 conditional = (???*0* !== {}) +919 -> 925 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -921 -> 922 call = (...) => {"type": "array_constant", "elements": ???*0*}(???*1*, (???*2* | [])) +925 -> 926 call = (...) => {"type": "array_constant", "elements": ???*0*}(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -3320,183 +3320,183 @@ - *2* s4 ⚠️ pattern without value -0 -> 923 unreachable = ???*0* +0 -> 927 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 925 member call = ???*0*["charCodeAt"](???*1*) +0 -> 929 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 926 conditional = (???*0* === 123) +0 -> 930 conditional = (???*0* === 123) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -926 -> 927 conditional = ((0 | ???*0*) === 0) +930 -> 931 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -927 -> 928 call = (...) => undefined( +931 -> 932 call = (...) => undefined( {"type": "literal", "text": "{", "ignoreCase": false} ) -0 -> 929 conditional = (???*0* !== {}) +0 -> 933 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -929 -> 930 call = (...) => s0() +933 -> 934 call = (...) => s0() -929 -> 931 conditional = ((???*0* | []) !== {}) +933 -> 935 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -931 -> 932 call = (...) => s0() +935 -> 936 call = (...) => s0() -931 -> 933 conditional = (???*0* !== {}) +935 -> 937 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -933 -> 934 call = (...) => s0() +937 -> 938 call = (...) => s0() -933 -> 935 conditional = (???*0* !== {}) +937 -> 939 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -935 -> 937 member call = ???*0*["charCodeAt"](???*1*) +939 -> 941 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -935 -> 938 conditional = (???*0* === 44) +939 -> 942 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -938 -> 939 conditional = ((0 | ???*0*) === 0) +942 -> 943 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -939 -> 940 call = (...) => undefined( +943 -> 944 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -935 -> 941 conditional = ((???*0* | "," | {}) !== {}) +939 -> 945 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -941 -> 942 call = (...) => s0() +945 -> 946 call = (...) => s0() -941 -> 943 conditional = ((???*0* | []) !== {}) +945 -> 947 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -943 -> 944 call = (...) => s0() +947 -> 948 call = (...) => s0() -943 -> 945 conditional = (???*0* !== {}) +947 -> 949 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -945 -> 946 call = (...) => v(???*0*, ???*1*) +949 -> 950 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -933 -> 948 member call = (???*0* | [])["push"](???*1*) +937 -> 952 member call = (???*0* | [])["push"](???*1*) - *0* s4 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -933 -> 949 call = (...) => s0() +937 -> 953 call = (...) => s0() -933 -> 950 conditional = (???*0* !== {}) +937 -> 954 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -950 -> 952 member call = ???*0*["charCodeAt"](???*1*) +954 -> 956 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -950 -> 953 conditional = (???*0* === 44) +954 -> 957 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -953 -> 954 conditional = ((0 | ???*0*) === 0) +957 -> 958 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -954 -> 955 call = (...) => undefined( +958 -> 959 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -950 -> 956 conditional = ((???*0* | "," | {}) !== {}) +954 -> 960 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -956 -> 957 call = (...) => s0() +960 -> 961 call = (...) => s0() -956 -> 958 conditional = ((???*0* | []) !== {}) +960 -> 962 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -958 -> 959 call = (...) => s0() +962 -> 963 call = (...) => s0() -958 -> 960 conditional = (???*0* !== {}) +962 -> 964 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -960 -> 961 call = (...) => v(???*0*, ???*1*) +964 -> 965 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -933 -> 962 conditional = ((???*0* | []) !== {}) +937 -> 966 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -962 -> 963 call = (...) => s0() +966 -> 967 call = (...) => s0() -962 -> 964 conditional = (???*0* !== {}) +966 -> 968 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -964 -> 966 member call = ???*0*["charCodeAt"](???*1*) +968 -> 970 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -964 -> 967 conditional = (???*0* === 125) +968 -> 971 conditional = (???*0* === 125) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -967 -> 968 conditional = ((0 | ???*0*) === 0) +971 -> 972 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -968 -> 969 call = (...) => undefined( +972 -> 973 call = (...) => undefined( {"type": "literal", "text": "}", "ignoreCase": false} ) -964 -> 970 conditional = (???*0* !== {}) +968 -> 974 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -970 -> 971 call = (...) => {"type": "object_constant", "properties": ???*0*}(???*1*, (???*2* | [])) +974 -> 975 call = (...) => {"type": "object_constant", "properties": ???*0*}(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -3504,93 +3504,93 @@ - *2* s4 ⚠️ pattern without value -0 -> 972 unreachable = ???*0* +0 -> 976 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 973 call = (...) => s0() +0 -> 977 call = (...) => s0() -0 -> 974 conditional = (???*0* === {}) +0 -> 978 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -974 -> 975 call = (...) => s0() +978 -> 979 call = (...) => s0() -0 -> 977 member call = (???*0* | [])["push"](???*1*) +0 -> 981 member call = (???*0* | [])["push"](???*1*) - *0* s0 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 978 call = (...) => s0() +0 -> 982 call = (...) => s0() -0 -> 979 conditional = (???*0* === {}) +0 -> 983 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -979 -> 980 call = (...) => s0() +983 -> 984 call = (...) => s0() -0 -> 981 unreachable = ???*0* +0 -> 985 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 984 member call = ???*0*["charAt"](???*1*) +0 -> 988 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 985 member call = /^[ \t\n\r]/["test"](???*0*) +0 -> 989 member call = /^[ \t\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 986 conditional = /^[ \t\n\r]/["test"](???*0*) +0 -> 990 conditional = /^[ \t\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -986 -> 988 member call = ???*0*["charAt"](???*1*) +990 -> 992 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -986 -> 989 conditional = ((0 | ???*0*) === 0) +990 -> 993 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -989 -> 990 call = (...) => undefined( +993 -> 994 call = (...) => undefined( {"type": "class", "parts": [" ", "\t", "\n", "\r"], "inverted": false, "ignoreCase": false} ) -0 -> 991 unreachable = ???*0* +0 -> 995 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 993 member call = ???*0*["substr"](???*1*, 2) +0 -> 997 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 994 conditional = (???*0* === "--") +0 -> 998 conditional = (???*0* === "--") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -994 -> 995 conditional = ((0 | ???*0*) === 0) +998 -> 999 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -995 -> 996 call = (...) => undefined( +999 -> 1000 call = (...) => undefined( {"type": "literal", "text": "--", "ignoreCase": false} ) -0 -> 997 conditional = ((???*0* | "--" | {} | [???*1*, (???*2* | [])]) !== {}) +0 -> 1001 conditional = ((???*0* | "--" | {} | [???*1*, (???*2* | [])]) !== {}) - *0* s1 ⚠️ pattern without value - *1* s1 @@ -3598,105 +3598,105 @@ - *2* s2 ⚠️ pattern without value -997 -> 1000 member call = ???*0*["charAt"](???*1*) +1001 -> 1004 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -997 -> 1001 member call = /^[\n\r]/["test"](???*0*) +1001 -> 1005 member call = /^[\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -997 -> 1002 conditional = /^[\n\r]/["test"](???*0*) +1001 -> 1006 conditional = /^[\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1002 -> 1004 member call = ???*0*["charAt"](???*1*) +1006 -> 1008 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1002 -> 1005 conditional = ((0 | ???*0*) === 0) +1006 -> 1009 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1005 -> 1006 call = (...) => undefined( +1009 -> 1010 call = (...) => undefined( {"type": "class", "parts": ["\n", "\r"], "inverted": false, "ignoreCase": false} ) -997 -> 1007 conditional = (???*0* !== {}) +1001 -> 1011 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1007 -> 1008 call = (...) => s0() +1011 -> 1012 call = (...) => s0() -997 -> 1010 member call = (???*0* | [])["push"](???*1*) +1001 -> 1014 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -997 -> 1013 member call = ???*0*["charAt"](???*1*) +1001 -> 1017 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -997 -> 1014 member call = /^[\n\r]/["test"](???*0*) +1001 -> 1018 member call = /^[\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -997 -> 1015 conditional = /^[\n\r]/["test"](???*0*) +1001 -> 1019 conditional = /^[\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1015 -> 1017 member call = ???*0*["charAt"](???*1*) +1019 -> 1021 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1015 -> 1018 conditional = ((0 | ???*0*) === 0) +1019 -> 1022 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1018 -> 1019 call = (...) => undefined( +1022 -> 1023 call = (...) => undefined( {"type": "class", "parts": ["\n", "\r"], "inverted": false, "ignoreCase": false} ) -997 -> 1020 conditional = (???*0* !== {}) +1001 -> 1024 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1020 -> 1021 call = (...) => s0() +1024 -> 1025 call = (...) => s0() -0 -> 1022 unreachable = ???*0* +0 -> 1026 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1025 member call = ???*0*["substr"](???*1*, 6) +0 -> 1029 member call = ???*0*["substr"](???*1*, 6) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1026 member call = ???*0*["toLowerCase"]() +0 -> 1030 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 6) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1027 conditional = (???*0* === "select") +0 -> 1031 conditional = (???*0* === "select") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3706,43 +3706,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1027 -> 1029 member call = ???*0*["substr"](???*1*, 6) +1031 -> 1033 member call = ???*0*["substr"](???*1*, 6) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1027 -> 1030 conditional = ((0 | ???*0*) === 0) +1031 -> 1034 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1030 -> 1031 call = (...) => undefined( +1034 -> 1035 call = (...) => undefined( {"type": "literal", "text": "SELECT", "ignoreCase": true} ) -0 -> 1032 conditional = (???*0* !== {}) +0 -> 1036 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1032 -> 1033 call = (...) => s0() +1036 -> 1037 call = (...) => s0() -0 -> 1034 unreachable = ???*0* +0 -> 1038 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1037 member call = ???*0*["substr"](???*1*, 3) +0 -> 1041 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1038 member call = ???*0*["toLowerCase"]() +0 -> 1042 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1039 conditional = (???*0* === "top") +0 -> 1043 conditional = (???*0* === "top") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3752,43 +3752,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1039 -> 1041 member call = ???*0*["substr"](???*1*, 3) +1043 -> 1045 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1039 -> 1042 conditional = ((0 | ???*0*) === 0) +1043 -> 1046 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1042 -> 1043 call = (...) => undefined( +1046 -> 1047 call = (...) => undefined( {"type": "literal", "text": "TOP", "ignoreCase": true} ) -0 -> 1044 conditional = (???*0* !== {}) +0 -> 1048 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1044 -> 1045 call = (...) => s0() +1048 -> 1049 call = (...) => s0() -0 -> 1046 unreachable = ???*0* +0 -> 1050 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1049 member call = ???*0*["substr"](???*1*, 4) +0 -> 1053 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1050 member call = ???*0*["toLowerCase"]() +0 -> 1054 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 4) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1051 conditional = (???*0* === "from") +0 -> 1055 conditional = (???*0* === "from") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3798,43 +3798,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1051 -> 1053 member call = ???*0*["substr"](???*1*, 4) +1055 -> 1057 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1051 -> 1054 conditional = ((0 | ???*0*) === 0) +1055 -> 1058 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1054 -> 1055 call = (...) => undefined( +1058 -> 1059 call = (...) => undefined( {"type": "literal", "text": "FROM", "ignoreCase": true} ) -0 -> 1056 conditional = (???*0* !== {}) +0 -> 1060 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1056 -> 1057 call = (...) => s0() +1060 -> 1061 call = (...) => s0() -0 -> 1058 unreachable = ???*0* +0 -> 1062 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1061 member call = ???*0*["substr"](???*1*, 5) +0 -> 1065 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1062 member call = ???*0*["toLowerCase"]() +0 -> 1066 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 5) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1063 conditional = (???*0* === "where") +0 -> 1067 conditional = (???*0* === "where") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3844,43 +3844,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1063 -> 1065 member call = ???*0*["substr"](???*1*, 5) +1067 -> 1069 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1063 -> 1066 conditional = ((0 | ???*0*) === 0) +1067 -> 1070 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1066 -> 1067 call = (...) => undefined( +1070 -> 1071 call = (...) => undefined( {"type": "literal", "text": "WHERE", "ignoreCase": true} ) -0 -> 1068 conditional = (???*0* !== {}) +0 -> 1072 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1068 -> 1069 call = (...) => s0() +1072 -> 1073 call = (...) => s0() -0 -> 1070 unreachable = ???*0* +0 -> 1074 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1073 member call = ???*0*["substr"](???*1*, 5) +0 -> 1077 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1074 member call = ???*0*["toLowerCase"]() +0 -> 1078 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 5) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1075 conditional = (???*0* === "order") +0 -> 1079 conditional = (???*0* === "order") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3890,43 +3890,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1075 -> 1077 member call = ???*0*["substr"](???*1*, 5) +1079 -> 1081 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1075 -> 1078 conditional = ((0 | ???*0*) === 0) +1079 -> 1082 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1078 -> 1079 call = (...) => undefined( +1082 -> 1083 call = (...) => undefined( {"type": "literal", "text": "ORDER", "ignoreCase": true} ) -0 -> 1080 conditional = (???*0* !== {}) +0 -> 1084 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1080 -> 1081 call = (...) => s0() +1084 -> 1085 call = (...) => s0() -0 -> 1082 unreachable = ???*0* +0 -> 1086 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1085 member call = ???*0*["substr"](???*1*, 2) +0 -> 1089 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1086 member call = ???*0*["toLowerCase"]() +0 -> 1090 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1087 conditional = (???*0* === "by") +0 -> 1091 conditional = (???*0* === "by") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3936,43 +3936,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1087 -> 1089 member call = ???*0*["substr"](???*1*, 2) +1091 -> 1093 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1087 -> 1090 conditional = ((0 | ???*0*) === 0) +1091 -> 1094 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1090 -> 1091 call = (...) => undefined( +1094 -> 1095 call = (...) => undefined( {"type": "literal", "text": "BY", "ignoreCase": true} ) -0 -> 1092 conditional = (???*0* !== {}) +0 -> 1096 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1092 -> 1093 call = (...) => s0() +1096 -> 1097 call = (...) => s0() -0 -> 1094 unreachable = ???*0* +0 -> 1098 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1097 member call = ???*0*["substr"](???*1*, 2) +0 -> 1101 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1098 member call = ???*0*["toLowerCase"]() +0 -> 1102 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1099 conditional = (???*0* === "as") +0 -> 1103 conditional = (???*0* === "as") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3982,43 +3982,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1099 -> 1101 member call = ???*0*["substr"](???*1*, 2) +1103 -> 1105 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1099 -> 1102 conditional = ((0 | ???*0*) === 0) +1103 -> 1106 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1102 -> 1103 call = (...) => undefined( +1106 -> 1107 call = (...) => undefined( {"type": "literal", "text": "AS", "ignoreCase": true} ) -0 -> 1104 conditional = (???*0* !== {}) +0 -> 1108 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1104 -> 1105 call = (...) => s0() +1108 -> 1109 call = (...) => s0() -0 -> 1106 unreachable = ???*0* +0 -> 1110 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1109 member call = ???*0*["substr"](???*1*, 4) +0 -> 1113 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1110 member call = ???*0*["toLowerCase"]() +0 -> 1114 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 4) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1111 conditional = (???*0* === "join") +0 -> 1115 conditional = (???*0* === "join") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -4028,43 +4028,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1111 -> 1113 member call = ???*0*["substr"](???*1*, 4) +1115 -> 1117 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1111 -> 1114 conditional = ((0 | ???*0*) === 0) +1115 -> 1118 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1114 -> 1115 call = (...) => undefined( +1118 -> 1119 call = (...) => undefined( {"type": "literal", "text": "JOIN", "ignoreCase": true} ) -0 -> 1116 conditional = (???*0* !== {}) +0 -> 1120 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1116 -> 1117 call = (...) => s0() +1120 -> 1121 call = (...) => s0() -0 -> 1118 unreachable = ???*0* +0 -> 1122 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1121 member call = ???*0*["substr"](???*1*, 2) +0 -> 1125 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1122 member call = ???*0*["toLowerCase"]() +0 -> 1126 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1123 conditional = (???*0* === "in") +0 -> 1127 conditional = (???*0* === "in") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -4074,43 +4074,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1123 -> 1125 member call = ???*0*["substr"](???*1*, 2) +1127 -> 1129 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1123 -> 1126 conditional = ((0 | ???*0*) === 0) +1127 -> 1130 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1126 -> 1127 call = (...) => undefined( +1130 -> 1131 call = (...) => undefined( {"type": "literal", "text": "IN", "ignoreCase": true} ) -0 -> 1128 conditional = (???*0* !== {}) +0 -> 1132 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1128 -> 1129 call = (...) => s0() +1132 -> 1133 call = (...) => s0() -0 -> 1130 unreachable = ???*0* +0 -> 1134 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1133 member call = ???*0*["substr"](???*1*, 5) +0 -> 1137 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1134 member call = ???*0*["toLowerCase"]() +0 -> 1138 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 5) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1135 conditional = (???*0* === "value") +0 -> 1139 conditional = (???*0* === "value") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -4120,43 +4120,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1135 -> 1137 member call = ???*0*["substr"](???*1*, 5) +1139 -> 1141 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1135 -> 1138 conditional = ((0 | ???*0*) === 0) +1139 -> 1142 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1138 -> 1139 call = (...) => undefined( +1142 -> 1143 call = (...) => undefined( {"type": "literal", "text": "VALUE", "ignoreCase": true} ) -0 -> 1140 conditional = (???*0* !== {}) +0 -> 1144 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1140 -> 1141 call = (...) => s0() +1144 -> 1145 call = (...) => s0() -0 -> 1142 unreachable = ???*0* +0 -> 1146 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1145 member call = ???*0*["substr"](???*1*, 3) +0 -> 1149 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1146 member call = ???*0*["toLowerCase"]() +0 -> 1150 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1147 conditional = (???*0* === "asc") +0 -> 1151 conditional = (???*0* === "asc") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -4166,21 +4166,21 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1147 -> 1149 member call = ???*0*["substr"](???*1*, 3) +1151 -> 1153 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1147 -> 1150 conditional = ((0 | ???*0*) === 0) +1151 -> 1154 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1150 -> 1151 call = (...) => undefined( +1154 -> 1155 call = (...) => undefined( {"type": "literal", "text": "ASC", "ignoreCase": true} ) -0 -> 1152 conditional = ((???*0* | ???*1* | {} | "ASC") !== {}) +0 -> 1156 conditional = ((???*0* | ???*1* | {} | "ASC") !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substr"](peg$currPos, 3) @@ -4188,31 +4188,31 @@ - *2* arguments[0] ⚠️ function calls are not analyzed yet -1152 -> 1153 call = (...) => s0() +1156 -> 1157 call = (...) => s0() -1152 -> 1154 conditional = (???*0* !== {}) +1156 -> 1158 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1154 -> 1155 call = (...) => "ASC"() +1158 -> 1159 call = (...) => "ASC"() -0 -> 1156 unreachable = ???*0* +0 -> 1160 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1159 member call = ???*0*["substr"](???*1*, 4) +0 -> 1163 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1160 member call = ???*0*["toLowerCase"]() +0 -> 1164 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 4) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1161 conditional = (???*0* === "desc") +0 -> 1165 conditional = (???*0* === "desc") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -4222,21 +4222,21 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1161 -> 1163 member call = ???*0*["substr"](???*1*, 4) +1165 -> 1167 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1161 -> 1164 conditional = ((0 | ???*0*) === 0) +1165 -> 1168 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1164 -> 1165 call = (...) => undefined( +1168 -> 1169 call = (...) => undefined( {"type": "literal", "text": "DESC", "ignoreCase": true} ) -0 -> 1166 conditional = ((???*0* | ???*1* | {} | "DESC") !== {}) +0 -> 1170 conditional = ((???*0* | ???*1* | {} | "DESC") !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substr"](peg$currPos, 4) @@ -4244,31 +4244,31 @@ - *2* arguments[0] ⚠️ function calls are not analyzed yet -1166 -> 1167 call = (...) => s0() +1170 -> 1171 call = (...) => s0() -1166 -> 1168 conditional = (???*0* !== {}) +1170 -> 1172 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1168 -> 1169 call = (...) => "DESC"() +1172 -> 1173 call = (...) => "DESC"() -0 -> 1170 unreachable = ???*0* +0 -> 1174 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1173 member call = ???*0*["substr"](???*1*, 3) +0 -> 1177 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1174 member call = ???*0*["toLowerCase"]() +0 -> 1178 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1175 conditional = (???*0* === "and") +0 -> 1179 conditional = (???*0* === "and") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -4278,21 +4278,21 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1175 -> 1177 member call = ???*0*["substr"](???*1*, 3) +1179 -> 1181 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1175 -> 1178 conditional = ((0 | ???*0*) === 0) +1179 -> 1182 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1178 -> 1179 call = (...) => undefined( +1182 -> 1183 call = (...) => undefined( {"type": "literal", "text": "AND", "ignoreCase": true} ) -0 -> 1180 conditional = ((???*0* | ???*1* | {} | "AND") !== {}) +0 -> 1184 conditional = ((???*0* | ???*1* | {} | "AND") !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substr"](peg$currPos, 3) @@ -4300,31 +4300,31 @@ - *2* arguments[0] ⚠️ function calls are not analyzed yet -1180 -> 1181 call = (...) => s0() +1184 -> 1185 call = (...) => s0() -1180 -> 1182 conditional = (???*0* !== {}) +1184 -> 1186 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1182 -> 1183 call = (...) => "AND"() +1186 -> 1187 call = (...) => "AND"() -0 -> 1184 unreachable = ???*0* +0 -> 1188 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1187 member call = ???*0*["substr"](???*1*, 2) +0 -> 1191 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1188 member call = ???*0*["toLowerCase"]() +0 -> 1192 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1189 conditional = (???*0* === "or") +0 -> 1193 conditional = (???*0* === "or") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -4334,21 +4334,21 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1189 -> 1191 member call = ???*0*["substr"](???*1*, 2) +1193 -> 1195 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1189 -> 1192 conditional = ((0 | ???*0*) === 0) +1193 -> 1196 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1192 -> 1193 call = (...) => undefined( +1196 -> 1197 call = (...) => undefined( {"type": "literal", "text": "OR", "ignoreCase": true} ) -0 -> 1194 conditional = ((???*0* | ???*1* | {} | "OR") !== {}) +0 -> 1198 conditional = ((???*0* | ???*1* | {} | "OR") !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substr"](peg$currPos, 2) @@ -4356,31 +4356,31 @@ - *2* arguments[0] ⚠️ function calls are not analyzed yet -1194 -> 1195 call = (...) => s0() +1198 -> 1199 call = (...) => s0() -1194 -> 1196 conditional = (???*0* !== {}) +1198 -> 1200 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1196 -> 1197 call = (...) => "OR"() +1200 -> 1201 call = (...) => "OR"() -0 -> 1198 unreachable = ???*0* +0 -> 1202 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1201 member call = ???*0*["substr"](???*1*, 3) +0 -> 1205 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1202 member call = ???*0*["toLowerCase"]() +0 -> 1206 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1203 conditional = (???*0* === "not") +0 -> 1207 conditional = (???*0* === "not") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -4390,21 +4390,21 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1203 -> 1205 member call = ???*0*["substr"](???*1*, 3) +1207 -> 1209 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1203 -> 1206 conditional = ((0 | ???*0*) === 0) +1207 -> 1210 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1206 -> 1207 call = (...) => undefined( +1210 -> 1211 call = (...) => undefined( {"type": "literal", "text": "NOT", "ignoreCase": true} ) -0 -> 1208 conditional = ((???*0* | ???*1* | {} | "NOT") !== {}) +0 -> 1212 conditional = ((???*0* | ???*1* | {} | "NOT") !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substr"](peg$currPos, 3) @@ -4412,31 +4412,31 @@ - *2* arguments[0] ⚠️ function calls are not analyzed yet -1208 -> 1209 call = (...) => s0() +1212 -> 1213 call = (...) => s0() -1208 -> 1210 conditional = (???*0* !== {}) +1212 -> 1214 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1210 -> 1211 call = (...) => "NOT"() +1214 -> 1215 call = (...) => "NOT"() -0 -> 1212 unreachable = ???*0* +0 -> 1216 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1215 member call = ???*0*["substr"](???*1*, 7) +0 -> 1219 member call = ???*0*["substr"](???*1*, 7) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1216 member call = ???*0*["toLowerCase"]() +0 -> 1220 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 7) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1217 conditional = (???*0* === "between") +0 -> 1221 conditional = (???*0* === "between") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -4446,43 +4446,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1217 -> 1219 member call = ???*0*["substr"](???*1*, 7) +1221 -> 1223 member call = ???*0*["substr"](???*1*, 7) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1217 -> 1220 conditional = ((0 | ???*0*) === 0) +1221 -> 1224 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1220 -> 1221 call = (...) => undefined( +1224 -> 1225 call = (...) => undefined( {"type": "literal", "text": "BETWEEN", "ignoreCase": true} ) -0 -> 1222 conditional = (???*0* !== {}) +0 -> 1226 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1222 -> 1223 call = (...) => s0() +1226 -> 1227 call = (...) => s0() -0 -> 1224 unreachable = ???*0* +0 -> 1228 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1227 member call = ???*0*["substr"](???*1*, 6) +0 -> 1231 member call = ???*0*["substr"](???*1*, 6) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1228 member call = ???*0*["toLowerCase"]() +0 -> 1232 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 6) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1229 conditional = (???*0* === "exists") +0 -> 1233 conditional = (???*0* === "exists") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -4492,43 +4492,43 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1229 -> 1231 member call = ???*0*["substr"](???*1*, 6) +1233 -> 1235 member call = ???*0*["substr"](???*1*, 6) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1229 -> 1232 conditional = ((0 | ???*0*) === 0) +1233 -> 1236 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1232 -> 1233 call = (...) => undefined( +1236 -> 1237 call = (...) => undefined( {"type": "literal", "text": "EXISTS", "ignoreCase": true} ) -0 -> 1234 conditional = (???*0* !== {}) +0 -> 1238 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1234 -> 1235 call = (...) => s0() +1238 -> 1239 call = (...) => s0() -0 -> 1236 unreachable = ???*0* +0 -> 1240 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1239 member call = ???*0*["substr"](???*1*, 5) +0 -> 1243 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1240 member call = ???*0*["toLowerCase"]() +0 -> 1244 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 5) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1241 conditional = (???*0* === "array") +0 -> 1245 conditional = (???*0* === "array") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -4538,165 +4538,153 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1241 -> 1243 member call = ???*0*["substr"](???*1*, 5) +1245 -> 1247 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1241 -> 1244 conditional = ((0 | ???*0*) === 0) +1245 -> 1248 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1244 -> 1245 call = (...) => undefined( +1248 -> 1249 call = (...) => undefined( {"type": "literal", "text": "ARRAY", "ignoreCase": true} ) -0 -> 1246 conditional = (???*0* !== {}) +0 -> 1250 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1246 -> 1247 call = (...) => s0() +1250 -> 1251 call = (...) => s0() -0 -> 1248 unreachable = ???*0* +0 -> 1252 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1250 member call = ???*0*["substr"](???*1*, 4) +0 -> 1254 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1251 conditional = (???*0* === "null") +0 -> 1255 conditional = (???*0* === "null") - *0* ???*1*["substr"](peg$currPos, 4) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1251 -> 1252 conditional = ((0 | ???*0*) === 0) +1255 -> 1256 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1252 -> 1253 call = (...) => undefined( +1256 -> 1257 call = (...) => undefined( {"type": "literal", "text": "null", "ignoreCase": false} ) -0 -> 1254 conditional = (???*0* !== {}) +0 -> 1258 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1254 -> 1255 call = (...) => s0() +1258 -> 1259 call = (...) => s0() -0 -> 1256 unreachable = ???*0* +0 -> 1260 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1258 member call = ???*0*["substr"](???*1*, 4) +0 -> 1262 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1259 conditional = (???*0* === "true") +0 -> 1263 conditional = (???*0* === "true") - *0* ???*1*["substr"](peg$currPos, 4) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1259 -> 1260 conditional = ((0 | ???*0*) === 0) +1263 -> 1264 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1260 -> 1261 call = (...) => undefined( +1264 -> 1265 call = (...) => undefined( {"type": "literal", "text": "true", "ignoreCase": false} ) -0 -> 1262 conditional = (???*0* !== {}) +0 -> 1266 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1262 -> 1263 call = (...) => s0() +1266 -> 1267 call = (...) => s0() -0 -> 1264 unreachable = ???*0* +0 -> 1268 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1266 member call = ???*0*["substr"](???*1*, 5) +0 -> 1270 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1267 conditional = (???*0* === "false") +0 -> 1271 conditional = (???*0* === "false") - *0* ???*1*["substr"](peg$currPos, 5) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1267 -> 1268 conditional = ((0 | ???*0*) === 0) +1271 -> 1272 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1268 -> 1269 call = (...) => undefined( +1272 -> 1273 call = (...) => undefined( {"type": "literal", "text": "false", "ignoreCase": false} ) -0 -> 1270 conditional = (???*0* !== {}) +0 -> 1274 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1270 -> 1271 call = (...) => s0() +1274 -> 1275 call = (...) => s0() -0 -> 1272 unreachable = ???*0* +0 -> 1276 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1274 member call = ???*0*["substr"](???*1*, 3) +0 -> 1278 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1275 conditional = (???*0* === "udf") +0 -> 1279 conditional = (???*0* === "udf") - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1275 -> 1276 conditional = ((0 | ???*0*) === 0) +1279 -> 1280 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1276 -> 1277 call = (...) => undefined( +1280 -> 1281 call = (...) => undefined( {"type": "literal", "text": "udf", "ignoreCase": false} ) -0 -> 1278 conditional = (???*0* !== {}) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -1278 -> 1279 call = (...) => s0() - -0 -> 1280 unreachable = ???*0* -- *0* unreachable - ⚠️ This value might have side effects - -0 -> 1281 call = (...) => s0() - -0 -> 1282 conditional = (???*0* === {}) +0 -> 1282 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects 1282 -> 1283 call = (...) => s0() -1282 -> 1284 conditional = (???*0* === {}) -- *0* max number of linking steps reached +0 -> 1284 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -1284 -> 1285 call = (...) => s0() +0 -> 1285 call = (...) => s0() -1284 -> 1286 conditional = (???*0* === {}) +0 -> 1286 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects @@ -4810,69 +4798,81 @@ 1322 -> 1323 call = (...) => s0() -0 -> 1324 unreachable = ???*0* -- *0* unreachable +1322 -> 1324 conditional = (???*0* === {}) +- *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1325 call = (...) => s0() +1324 -> 1325 call = (...) => s0() -0 -> 1326 conditional = (???*0* !== {}) +1324 -> 1326 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects 1326 -> 1327 call = (...) => s0() -1326 -> 1328 conditional = (???*0* !== {}) +0 -> 1328 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1329 call = (...) => s0() + +0 -> 1330 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1328 -> 1329 call = (...) => {"type": "identifier", "name": name}(???*0*) +1330 -> 1331 call = (...) => s0() + +1330 -> 1332 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1330 unreachable = ???*0* +1332 -> 1333 call = (...) => {"type": "identifier", "name": name}(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 1334 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1333 member call = ???*0*["charAt"](???*1*) +0 -> 1337 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1334 member call = /^[a-zA-Z_]/["test"](???*0*) +0 -> 1338 member call = /^[a-zA-Z_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1335 conditional = /^[a-zA-Z_]/["test"](???*0*) +0 -> 1339 conditional = /^[a-zA-Z_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1335 -> 1337 member call = ???*0*["charAt"](???*1*) +1339 -> 1341 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1335 -> 1338 conditional = ((0 | ???*0*) === 0) +1339 -> 1342 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1338 -> 1339 call = (...) => undefined( +1342 -> 1343 call = (...) => undefined( {"type": "class", "parts": [["a", "z"], ["A", "Z"], "_"], "inverted": false, "ignoreCase": false} ) -0 -> 1340 unreachable = ???*0* +0 -> 1344 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1341 call = (...) => s0() +0 -> 1345 call = (...) => s0() -0 -> 1342 conditional = ((???*0* | ???*1* | {} | ???*3*) !== {}) +0 -> 1346 conditional = ((???*0* | ???*1* | {} | ???*3*) !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["charAt"](peg$currPos) @@ -4892,35 +4892,35 @@ - *8* []["join"] ⚠️ non-num constant property on array -1342 -> 1345 member call = ???*0*["charAt"](???*1*) +1346 -> 1349 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1342 -> 1346 member call = /^[a-zA-Z0-9_]/["test"](???*0*) +1346 -> 1350 member call = /^[a-zA-Z0-9_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1342 -> 1347 conditional = /^[a-zA-Z0-9_]/["test"](???*0*) +1346 -> 1351 conditional = /^[a-zA-Z0-9_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1347 -> 1349 member call = ???*0*["charAt"](???*1*) +1351 -> 1353 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1347 -> 1350 conditional = ((0 | ???*0*) === 0) +1351 -> 1354 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1350 -> 1351 call = (...) => undefined( +1354 -> 1355 call = (...) => undefined( { "type": "class", "parts": [["a", "z"], ["A", "Z"], ["0", "9"], "_"], @@ -4929,7 +4929,7 @@ } ) -1342 -> 1353 member call = (???*0* | [])["push"]((???*1* | ???*2* | {})) +1346 -> 1357 member call = (???*0* | [])["push"]((???*1* | ???*2* | {})) - *0* s2 ⚠️ pattern without value - *1* s3 @@ -4939,35 +4939,35 @@ - *3* arguments[0] ⚠️ function calls are not analyzed yet -1342 -> 1356 member call = ???*0*["charAt"](???*1*) +1346 -> 1360 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1342 -> 1357 member call = /^[a-zA-Z0-9_]/["test"](???*0*) +1346 -> 1361 member call = /^[a-zA-Z0-9_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1342 -> 1358 conditional = /^[a-zA-Z0-9_]/["test"](???*0*) +1346 -> 1362 conditional = /^[a-zA-Z0-9_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1358 -> 1360 member call = ???*0*["charAt"](???*1*) +1362 -> 1364 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1358 -> 1361 conditional = ((0 | ???*0*) === 0) +1362 -> 1365 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1361 -> 1362 call = (...) => undefined( +1365 -> 1366 call = (...) => undefined( { "type": "class", "parts": [["a", "z"], ["A", "Z"], ["0", "9"], "_"], @@ -4976,11 +4976,11 @@ } ) -1342 -> 1363 conditional = ((???*0* | []) !== {}) +1346 -> 1367 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1363 -> 1364 call = (...) => (head + tail["join"](""))( +1367 -> 1368 call = (...) => (head + tail["join"](""))( (???*0* | ???*1* | {} | (???*3* + (???*4* | ???*6*))), (???*8* | []) ) @@ -5003,31 +5003,31 @@ - *8* s2 ⚠️ pattern without value -0 -> 1365 unreachable = ???*0* +0 -> 1369 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1367 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1371 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1368 conditional = (???*0* === 64) +0 -> 1372 conditional = (???*0* === 64) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1368 -> 1369 conditional = ((0 | ???*0*) === 0) +1372 -> 1373 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1369 -> 1370 call = (...) => undefined( +1373 -> 1374 call = (...) => undefined( {"type": "literal", "text": "@", "ignoreCase": false} ) -0 -> 1371 conditional = ((???*0* | "@" | {} | {"type": "parameter_name", "name": ???*1*}) !== {}) +0 -> 1375 conditional = ((???*0* | "@" | {} | {"type": "parameter_name", "name": ???*1*}) !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substring"](peg$savedPos, peg$currPos) @@ -5035,629 +5035,629 @@ - *2* arguments[0] ⚠️ function calls are not analyzed yet -1371 -> 1372 call = (...) => s0() +1375 -> 1376 call = (...) => s0() -1371 -> 1373 conditional = (???*0* !== {}) +1375 -> 1377 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1374 call = (...) => {"type": "parameter_name", "name": text()}() +1377 -> 1378 call = (...) => {"type": "parameter_name", "name": text()}() -0 -> 1375 unreachable = ???*0* +0 -> 1379 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1377 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1381 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1378 conditional = (???*0* === 43) +0 -> 1382 conditional = (???*0* === 43) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1378 -> 1379 conditional = ((0 | ???*0*) === 0) +1382 -> 1383 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1379 -> 1380 call = (...) => undefined( +1383 -> 1384 call = (...) => undefined( {"type": "literal", "text": "+", "ignoreCase": false} ) -0 -> 1381 conditional = (???*0* === {}) +0 -> 1385 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1381 -> 1383 member call = ???*0*["charCodeAt"](???*1*) +1385 -> 1387 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1381 -> 1384 conditional = (???*0* === 45) +1385 -> 1388 conditional = (???*0* === 45) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1384 -> 1385 conditional = ((0 | ???*0*) === 0) +1388 -> 1389 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1385 -> 1386 call = (...) => undefined( +1389 -> 1390 call = (...) => undefined( {"type": "literal", "text": "-", "ignoreCase": false} ) -1381 -> 1387 conditional = (???*0* === {}) +1385 -> 1391 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1387 -> 1389 member call = ???*0*["charCodeAt"](???*1*) +1391 -> 1393 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1387 -> 1390 conditional = (???*0* === 126) +1391 -> 1394 conditional = (???*0* === 126) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1390 -> 1391 conditional = ((0 | ???*0*) === 0) +1394 -> 1395 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1391 -> 1392 call = (...) => undefined( +1395 -> 1396 call = (...) => undefined( {"type": "literal", "text": "~", "ignoreCase": false} ) -1387 -> 1393 conditional = (???*0* === {}) +1391 -> 1397 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1393 -> 1394 call = (...) => s0() +1397 -> 1398 call = (...) => s0() -0 -> 1395 unreachable = ???*0* +0 -> 1399 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1397 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1401 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1398 conditional = (???*0* === 34) +0 -> 1402 conditional = (???*0* === 34) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1398 -> 1399 conditional = ((0 | ???*0*) === 0) +1402 -> 1403 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1399 -> 1400 call = (...) => undefined( +1403 -> 1404 call = (...) => undefined( {"type": "literal", "text": "\"", "ignoreCase": false} ) -0 -> 1401 conditional = (???*0* === {}) +0 -> 1405 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1401 -> 1403 member call = ???*0*["charCodeAt"](???*1*) +1405 -> 1407 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1401 -> 1404 conditional = (???*0* === 92) +1405 -> 1408 conditional = (???*0* === 92) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1404 -> 1405 conditional = ((0 | ???*0*) === 0) +1408 -> 1409 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1405 -> 1406 call = (...) => undefined( +1409 -> 1410 call = (...) => undefined( {"type": "literal", "text": "\\", "ignoreCase": false} ) -0 -> 1407 conditional = (???*0* !== {}) +0 -> 1411 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1407 -> 1408 call = (...) => s0() +1411 -> 1412 call = (...) => s0() -1407 -> 1409 conditional = (???*0* !== {}) +1411 -> 1413 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1409 -> 1410 call = (...) => text()() +1413 -> 1414 call = (...) => text()() -0 -> 1411 conditional = (???*0* === {}) +0 -> 1415 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1411 -> 1413 member call = ???*0*["charCodeAt"](???*1*) +1415 -> 1417 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1411 -> 1414 conditional = (???*0* === 92) +1415 -> 1418 conditional = (???*0* === 92) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1414 -> 1415 conditional = ((0 | ???*0*) === 0) +1418 -> 1419 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1415 -> 1416 call = (...) => undefined( +1419 -> 1420 call = (...) => undefined( {"type": "literal", "text": "\\", "ignoreCase": false} ) -1411 -> 1417 conditional = (???*0* !== {}) +1415 -> 1421 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1417 -> 1418 call = (...) => s0() +1421 -> 1422 call = (...) => s0() -1417 -> 1419 conditional = (???*0* !== {}) +1421 -> 1423 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1419 -> 1420 call = (...) => seq(???*0*) +1423 -> 1424 call = (...) => seq(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1421 unreachable = ???*0* +0 -> 1425 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1423 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1427 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1424 conditional = (???*0* === 39) +0 -> 1428 conditional = (???*0* === 39) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1424 -> 1425 conditional = ((0 | ???*0*) === 0) +1428 -> 1429 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1425 -> 1426 call = (...) => undefined( +1429 -> 1430 call = (...) => undefined( {"type": "literal", "text": "'", "ignoreCase": false} ) -0 -> 1427 conditional = (???*0* === {}) +0 -> 1431 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1427 -> 1429 member call = ???*0*["charCodeAt"](???*1*) +1431 -> 1433 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1427 -> 1430 conditional = (???*0* === 92) +1431 -> 1434 conditional = (???*0* === 92) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1430 -> 1431 conditional = ((0 | ???*0*) === 0) +1434 -> 1435 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1431 -> 1432 call = (...) => undefined( +1435 -> 1436 call = (...) => undefined( {"type": "literal", "text": "\\", "ignoreCase": false} ) -0 -> 1433 conditional = (???*0* !== {}) +0 -> 1437 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1433 -> 1434 call = (...) => s0() +1437 -> 1438 call = (...) => s0() -1433 -> 1435 conditional = (???*0* !== {}) +1437 -> 1439 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1435 -> 1436 call = (...) => text()() +1439 -> 1440 call = (...) => text()() -0 -> 1437 conditional = (???*0* === {}) +0 -> 1441 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1437 -> 1439 member call = ???*0*["charCodeAt"](???*1*) +1441 -> 1443 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1437 -> 1440 conditional = (???*0* === 92) +1441 -> 1444 conditional = (???*0* === 92) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1440 -> 1441 conditional = ((0 | ???*0*) === 0) +1444 -> 1445 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1441 -> 1442 call = (...) => undefined( +1445 -> 1446 call = (...) => undefined( {"type": "literal", "text": "\\", "ignoreCase": false} ) -1437 -> 1443 conditional = (???*0* !== {}) +1441 -> 1447 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1443 -> 1444 call = (...) => s0() +1447 -> 1448 call = (...) => s0() -1443 -> 1445 conditional = (???*0* !== {}) +1447 -> 1449 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1445 -> 1446 call = (...) => seq(???*0*) +1449 -> 1450 call = (...) => seq(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1447 unreachable = ???*0* +0 -> 1451 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1450 member call = ???*0*["charAt"](???*1*) +0 -> 1454 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1451 conditional = ((0 | ???*0*) === 0) +0 -> 1455 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1451 -> 1452 call = (...) => undefined({"type": "any"}) +1455 -> 1456 call = (...) => undefined({"type": "any"}) -0 -> 1453 unreachable = ???*0* +0 -> 1457 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1454 call = (...) => s0() +0 -> 1458 call = (...) => s0() -0 -> 1455 conditional = (???*0* === {}) +0 -> 1459 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1455 -> 1456 call = (...) => s0() +1459 -> 1460 call = (...) => s0() -0 -> 1457 unreachable = ???*0* +0 -> 1461 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1458 call = (...) => s0() +0 -> 1462 call = (...) => s0() -0 -> 1459 conditional = (???*0* === {}) +0 -> 1463 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1459 -> 1460 call = (...) => s0() +1463 -> 1464 call = (...) => s0() -0 -> 1461 unreachable = ???*0* +0 -> 1465 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1463 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1467 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1464 conditional = (???*0* === 39) +0 -> 1468 conditional = (???*0* === 39) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1464 -> 1465 conditional = ((0 | ???*0*) === 0) +1468 -> 1469 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1465 -> 1466 call = (...) => undefined( +1469 -> 1470 call = (...) => undefined( {"type": "literal", "text": "'", "ignoreCase": false} ) -0 -> 1467 conditional = (???*0* === {}) +0 -> 1471 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1467 -> 1469 member call = ???*0*["charCodeAt"](???*1*) +1471 -> 1473 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1467 -> 1470 conditional = (???*0* === 34) +1471 -> 1474 conditional = (???*0* === 34) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1470 -> 1471 conditional = ((0 | ???*0*) === 0) +1474 -> 1475 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1471 -> 1472 call = (...) => undefined( +1475 -> 1476 call = (...) => undefined( {"type": "literal", "text": "\"", "ignoreCase": false} ) -1467 -> 1473 conditional = (???*0* === {}) +1471 -> 1477 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1473 -> 1475 member call = ???*0*["charCodeAt"](???*1*) +1477 -> 1479 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1473 -> 1476 conditional = (???*0* === 92) +1477 -> 1480 conditional = (???*0* === 92) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1476 -> 1477 conditional = ((0 | ???*0*) === 0) +1480 -> 1481 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1477 -> 1478 call = (...) => undefined( +1481 -> 1482 call = (...) => undefined( {"type": "literal", "text": "\\", "ignoreCase": false} ) -1473 -> 1479 conditional = (???*0* === {}) +1477 -> 1483 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1479 -> 1481 member call = ???*0*["charCodeAt"](???*1*) +1483 -> 1485 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1479 -> 1482 conditional = (???*0* === 98) +1483 -> 1486 conditional = (???*0* === 98) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1482 -> 1483 conditional = ((0 | ???*0*) === 0) +1486 -> 1487 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1483 -> 1484 call = (...) => undefined( +1487 -> 1488 call = (...) => undefined( {"type": "literal", "text": "b", "ignoreCase": false} ) -1479 -> 1485 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) +1483 -> 1489 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) - *0* s1 ⚠️ pattern without value -1485 -> 1486 call = (...) => "\b"() +1489 -> 1490 call = (...) => "\b"() -1479 -> 1487 conditional = (???*0* === {}) +1483 -> 1491 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1487 -> 1489 member call = ???*0*["charCodeAt"](???*1*) +1491 -> 1493 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1487 -> 1490 conditional = (???*0* === 102) +1491 -> 1494 conditional = (???*0* === 102) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1490 -> 1491 conditional = ((0 | ???*0*) === 0) +1494 -> 1495 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1491 -> 1492 call = (...) => undefined( +1495 -> 1496 call = (...) => undefined( {"type": "literal", "text": "f", "ignoreCase": false} ) -1487 -> 1493 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) +1491 -> 1497 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) - *0* s1 ⚠️ pattern without value -1493 -> 1494 call = (...) => "\f"() +1497 -> 1498 call = (...) => "\f"() -1487 -> 1495 conditional = (???*0* === {}) +1491 -> 1499 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1495 -> 1497 member call = ???*0*["charCodeAt"](???*1*) +1499 -> 1501 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1495 -> 1498 conditional = (???*0* === 110) +1499 -> 1502 conditional = (???*0* === 110) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1498 -> 1499 conditional = ((0 | ???*0*) === 0) +1502 -> 1503 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1499 -> 1500 call = (...) => undefined( +1503 -> 1504 call = (...) => undefined( {"type": "literal", "text": "n", "ignoreCase": false} ) -1495 -> 1501 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) +1499 -> 1505 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) - *0* s1 ⚠️ pattern without value -1501 -> 1502 call = (...) => "\n"() +1505 -> 1506 call = (...) => "\n"() -1495 -> 1503 conditional = (???*0* === {}) +1499 -> 1507 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1503 -> 1505 member call = ???*0*["charCodeAt"](???*1*) +1507 -> 1509 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1503 -> 1506 conditional = (???*0* === 114) +1507 -> 1510 conditional = (???*0* === 114) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1506 -> 1507 conditional = ((0 | ???*0*) === 0) +1510 -> 1511 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1507 -> 1508 call = (...) => undefined( +1511 -> 1512 call = (...) => undefined( {"type": "literal", "text": "r", "ignoreCase": false} ) -1503 -> 1509 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) +1507 -> 1513 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) - *0* s1 ⚠️ pattern without value -1509 -> 1510 call = (...) => "\r"() +1513 -> 1514 call = (...) => "\r"() -1503 -> 1511 conditional = (???*0* === {}) +1507 -> 1515 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1511 -> 1513 member call = ???*0*["charCodeAt"](???*1*) +1515 -> 1517 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1511 -> 1514 conditional = (???*0* === 116) +1515 -> 1518 conditional = (???*0* === 116) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1514 -> 1515 conditional = ((0 | ???*0*) === 0) +1518 -> 1519 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1515 -> 1516 call = (...) => undefined( +1519 -> 1520 call = (...) => undefined( {"type": "literal", "text": "t", "ignoreCase": false} ) -1511 -> 1517 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) +1515 -> 1521 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) - *0* s1 ⚠️ pattern without value -1517 -> 1518 call = (...) => "\t"() +1521 -> 1522 call = (...) => "\t"() -0 -> 1519 unreachable = ???*0* +0 -> 1523 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1520 call = (...) => s0() +0 -> 1524 call = (...) => s0() -0 -> 1521 conditional = (???*0* !== {}) +0 -> 1525 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1521 -> 1522 call = (...) => s0() +1525 -> 1526 call = (...) => s0() -1521 -> 1523 conditional = (???*0* !== {}) +1525 -> 1527 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1523 -> 1524 call = (...) => text()() +1527 -> 1528 call = (...) => text()() -0 -> 1525 unreachable = ???*0* +0 -> 1529 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1526 call = (...) => s0() +0 -> 1530 call = (...) => s0() -0 -> 1527 conditional = (???*0* === {}) +0 -> 1531 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1527 -> 1529 member call = ???*0*["charCodeAt"](???*1*) +1531 -> 1533 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1527 -> 1530 conditional = (???*0* === 117) +1531 -> 1534 conditional = (???*0* === 117) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1530 -> 1531 conditional = ((0 | ???*0*) === 0) +1534 -> 1535 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1531 -> 1532 call = (...) => undefined( +1535 -> 1536 call = (...) => undefined( {"type": "literal", "text": "u", "ignoreCase": false} ) -0 -> 1533 unreachable = ???*0* +0 -> 1537 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1535 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1539 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1536 conditional = (???*0* === 117) +0 -> 1540 conditional = (???*0* === 117) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1536 -> 1537 conditional = ((0 | ???*0*) === 0) +1540 -> 1541 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1537 -> 1538 call = (...) => undefined( +1541 -> 1542 call = (...) => undefined( {"type": "literal", "text": "u", "ignoreCase": false} ) -0 -> 1539 conditional = (???*0* !== {}) +0 -> 1543 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1539 -> 1540 call = (...) => s0() +1543 -> 1544 call = (...) => s0() -1539 -> 1541 conditional = (( +1543 -> 1545 conditional = (( | ???*0* | ???*1* | {} @@ -5690,9 +5690,9 @@ - *12* arguments[0] ⚠️ function calls are not analyzed yet -1541 -> 1542 call = (...) => s0() +1545 -> 1546 call = (...) => s0() -1541 -> 1543 conditional = ((???*0* | ???*1* | {}) !== {}) +1545 -> 1547 conditional = ((???*0* | ???*1* | {}) !== {}) - *0* s5 ⚠️ pattern without value - *1* ???*2*["charAt"](peg$currPos) @@ -5700,9 +5700,9 @@ - *2* arguments[0] ⚠️ function calls are not analyzed yet -1543 -> 1544 call = (...) => s0() +1547 -> 1548 call = (...) => s0() -1543 -> 1545 conditional = ((???*0* | ???*1* | {}) !== {}) +1547 -> 1549 conditional = ((???*0* | ???*1* | {}) !== {}) - *0* s6 ⚠️ pattern without value - *1* ???*2*["charAt"](peg$currPos) @@ -5710,13 +5710,13 @@ - *2* arguments[0] ⚠️ function calls are not analyzed yet -1545 -> 1546 call = (...) => s0() +1549 -> 1550 call = (...) => s0() -1539 -> 1547 conditional = (???*0* !== {}) +1543 -> 1551 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1547 -> 1549 member call = ???*0*["substring"](???*1*, ???*2*) +1551 -> 1553 member call = ???*0*["substring"](???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached @@ -5724,751 +5724,751 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -1539 -> 1550 conditional = (???*0* !== {}) +1543 -> 1554 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1550 -> 1551 call = (...) => FreeVar(String)["fromCharCode"](FreeVar(parseInt)(digits, 16))(???*0*) +1554 -> 1555 call = (...) => FreeVar(String)["fromCharCode"](FreeVar(parseInt)(digits, 16))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1552 unreachable = ???*0* +0 -> 1556 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1555 member call = ???*0*["charAt"](???*1*) +0 -> 1559 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1556 member call = /^[0-9a-f]/i["test"](???*0*) +0 -> 1560 member call = /^[0-9a-f]/i["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 1557 conditional = /^[0-9a-f]/i["test"](???*0*) +0 -> 1561 conditional = /^[0-9a-f]/i["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1557 -> 1559 member call = ???*0*["charAt"](???*1*) +1561 -> 1563 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1557 -> 1560 conditional = ((0 | ???*0*) === 0) +1561 -> 1564 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1560 -> 1561 call = (...) => undefined( +1564 -> 1565 call = (...) => undefined( {"type": "class", "parts": [["0", "9"], ["a", "f"]], "inverted": false, "ignoreCase": true} ) -0 -> 1562 unreachable = ???*0* +0 -> 1566 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1563 call = (...) => s0() +0 -> 1567 call = (...) => s0() -0 -> 1564 conditional = (???*0* !== {}) +0 -> 1568 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1564 -> 1565 call = (...) => s0() +1568 -> 1569 call = (...) => s0() -1564 -> 1566 conditional = (???*0* !== {}) +1568 -> 1570 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1566 -> 1567 call = (...) => s0() +1570 -> 1571 call = (...) => s0() -1564 -> 1568 conditional = (???*0* !== {}) +1568 -> 1572 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1568 -> 1569 call = (...) => s0() +1572 -> 1573 call = (...) => s0() -1568 -> 1570 conditional = (???*0* !== {}) +1572 -> 1574 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1570 -> 1571 call = (...) => s0() +1574 -> 1575 call = (...) => s0() -1570 -> 1572 conditional = (???*0* !== {}) +1574 -> 1576 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1572 -> 1573 call = (...) => v(???*0*, ???*1*) +1576 -> 1577 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1564 -> 1574 conditional = (???*0* !== {}) +1568 -> 1578 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1574 -> 1575 call = (...) => {"property": property, "alias": alias}(???*0*, ???*1*) +1578 -> 1579 call = (...) => {"property": property, "alias": alias}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1576 unreachable = ???*0* +0 -> 1580 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1577 call = (...) => s0() +0 -> 1581 call = (...) => s0() -0 -> 1578 conditional = (???*0* === {}) +0 -> 1582 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1578 -> 1579 call = (...) => s0() +1582 -> 1583 call = (...) => s0() -1578 -> 1580 conditional = (???*0* === {}) +1582 -> 1584 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1580 -> 1581 call = (...) => s0() +1584 -> 1585 call = (...) => s0() -1580 -> 1582 conditional = (???*0* === {}) +1584 -> 1586 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1582 -> 1583 call = (...) => s0() +1586 -> 1587 call = (...) => s0() -1582 -> 1584 conditional = (???*0* === {}) +1586 -> 1588 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1584 -> 1585 call = (...) => s0() +1588 -> 1589 call = (...) => s0() -1584 -> 1586 conditional = (???*0* === {}) +1588 -> 1590 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1586 -> 1587 call = (...) => s0() +1590 -> 1591 call = (...) => s0() -1586 -> 1588 conditional = (???*0* === {}) +1590 -> 1592 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1588 -> 1590 member call = ???*0*["charCodeAt"](???*1*) +1592 -> 1594 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1588 -> 1591 conditional = (???*0* === 40) +1592 -> 1595 conditional = (???*0* === 40) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1591 -> 1592 conditional = ((0 | ???*0*) === 0) +1595 -> 1596 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1592 -> 1593 call = (...) => undefined( +1596 -> 1597 call = (...) => undefined( {"type": "literal", "text": "(", "ignoreCase": false} ) -1588 -> 1594 conditional = (???*0* !== {}) +1592 -> 1598 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1594 -> 1595 call = (...) => s0() +1598 -> 1599 call = (...) => s0() -1594 -> 1596 conditional = ((???*0* | []) !== {}) +1598 -> 1600 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1596 -> 1597 call = (...) => s0() +1600 -> 1601 call = (...) => s0() -1596 -> 1598 conditional = (???*0* !== {}) +1600 -> 1602 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1598 -> 1599 call = (...) => s0() +1602 -> 1603 call = (...) => s0() -1598 -> 1600 conditional = ((???*0* | []) !== {}) +1602 -> 1604 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -1600 -> 1602 member call = ???*0*["charCodeAt"](???*1*) +1604 -> 1606 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1600 -> 1603 conditional = (???*0* === 41) +1604 -> 1607 conditional = (???*0* === 41) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1603 -> 1604 conditional = ((0 | ???*0*) === 0) +1607 -> 1608 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1604 -> 1605 call = (...) => undefined( +1608 -> 1609 call = (...) => undefined( {"type": "literal", "text": ")", "ignoreCase": false} ) -1600 -> 1606 conditional = ((???*0* | ")" | {}) !== {}) +1604 -> 1610 conditional = ((???*0* | ")" | {}) !== {}) - *0* s5 ⚠️ pattern without value -1606 -> 1607 call = (...) => expression(???*0*) +1610 -> 1611 call = (...) => expression(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1608 unreachable = ???*0* +0 -> 1612 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1609 call = (...) => s0() +0 -> 1613 call = (...) => s0() -0 -> 1610 conditional = (???*0* === {}) +0 -> 1614 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1610 -> 1611 call = (...) => s0() +1614 -> 1615 call = (...) => s0() -1610 -> 1612 conditional = (???*0* === {}) +1614 -> 1616 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1612 -> 1613 call = (...) => s0() +1616 -> 1617 call = (...) => s0() -0 -> 1614 unreachable = ???*0* +0 -> 1618 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1615 call = (...) => s0() +0 -> 1619 call = (...) => s0() -0 -> 1616 conditional = (???*0* !== {}) +0 -> 1620 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1616 -> 1617 call = (...) => s0() +1620 -> 1621 call = (...) => s0() -1616 -> 1618 conditional = ((???*0* | []) !== {}) +1620 -> 1622 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1618 -> 1619 call = (...) => s0() +1622 -> 1623 call = (...) => s0() -1618 -> 1620 conditional = (???*0* !== {}) +1622 -> 1624 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1620 -> 1621 call = (...) => {"type": "array_subquery_expression", "expression": expression}(???*0*) +1624 -> 1625 call = (...) => {"type": "array_subquery_expression", "expression": expression}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1622 unreachable = ???*0* +0 -> 1626 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1623 call = (...) => s0() +0 -> 1627 call = (...) => s0() -0 -> 1624 conditional = (???*0* !== {}) +0 -> 1628 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1624 -> 1625 call = (...) => s0() +1628 -> 1629 call = (...) => s0() -1624 -> 1626 conditional = ((???*0* | []) !== {}) +1628 -> 1630 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1626 -> 1627 call = (...) => s0() +1630 -> 1631 call = (...) => s0() -1626 -> 1628 conditional = (???*0* !== {}) +1630 -> 1632 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1628 -> 1629 call = (...) => {"type": "exists_subquery_expression", "expression": expression}(???*0*) +1632 -> 1633 call = (...) => {"type": "exists_subquery_expression", "expression": expression}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1630 unreachable = ???*0* +0 -> 1634 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1631 call = (...) => s0() +0 -> 1635 call = (...) => s0() -0 -> 1632 conditional = (???*0* !== {}) +0 -> 1636 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1632 -> 1633 call = (...) => {"type": "scalar_subquery_expression", "expression": expression}(???*0*) +1636 -> 1637 call = (...) => {"type": "scalar_subquery_expression", "expression": expression}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1634 unreachable = ???*0* +0 -> 1638 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1635 call = (...) => s0() +0 -> 1639 call = (...) => s0() -0 -> 1636 conditional = (???*0* !== {}) +0 -> 1640 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1636 -> 1637 call = (...) => s0() +1640 -> 1641 call = (...) => s0() -1636 -> 1638 conditional = (???*0* !== {}) +1640 -> 1642 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1638 -> 1640 member call = ???*0*["charCodeAt"](???*1*) +1642 -> 1644 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1638 -> 1641 conditional = (???*0* === 46) +1642 -> 1645 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1641 -> 1642 conditional = ((0 | ???*0*) === 0) +1645 -> 1646 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1642 -> 1643 call = (...) => undefined( +1646 -> 1647 call = (...) => undefined( {"type": "literal", "text": ".", "ignoreCase": false} ) -1638 -> 1644 conditional = ((???*0* | "." | {} | "[") !== {}) +1642 -> 1648 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -1644 -> 1645 call = (...) => s0() +1648 -> 1649 call = (...) => s0() -1644 -> 1646 conditional = ((???*0* | []) !== {}) +1648 -> 1650 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1646 -> 1647 call = (...) => s0() +1650 -> 1651 call = (...) => s0() -1646 -> 1648 conditional = (???*0* !== {}) +1650 -> 1652 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1648 -> 1649 call = (...) => s0() +1652 -> 1653 call = (...) => s0() -1648 -> 1650 conditional = ((???*0* | []) !== {}) +1652 -> 1654 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1650 -> 1651 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) +1654 -> 1655 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1636 -> 1652 conditional = (???*0* === {}) +1640 -> 1656 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1652 -> 1653 call = (...) => s0() +1656 -> 1657 call = (...) => s0() -1652 -> 1654 conditional = (???*0* !== {}) +1656 -> 1658 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1654 -> 1656 member call = ???*0*["charCodeAt"](???*1*) +1658 -> 1660 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1654 -> 1657 conditional = (???*0* === 91) +1658 -> 1661 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1657 -> 1658 conditional = ((0 | ???*0*) === 0) +1661 -> 1662 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1658 -> 1659 call = (...) => undefined( +1662 -> 1663 call = (...) => undefined( {"type": "literal", "text": "[", "ignoreCase": false} ) -1654 -> 1660 conditional = ((???*0* | "." | {} | "[") !== {}) +1658 -> 1664 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -1660 -> 1661 call = (...) => s0() +1664 -> 1665 call = (...) => s0() -1660 -> 1662 conditional = ((???*0* | []) !== {}) +1664 -> 1666 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1662 -> 1663 call = (...) => s0() +1666 -> 1667 call = (...) => s0() -1662 -> 1664 conditional = (???*0* === {}) +1666 -> 1668 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1664 -> 1665 call = (...) => s0() +1668 -> 1669 call = (...) => s0() -1664 -> 1666 conditional = (???*0* === {}) +1668 -> 1670 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1666 -> 1667 call = (...) => s0() +1670 -> 1671 call = (...) => s0() -1662 -> 1668 conditional = (???*0* !== {}) +1666 -> 1672 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1668 -> 1669 call = (...) => s0() +1672 -> 1673 call = (...) => s0() -1668 -> 1670 conditional = ((???*0* | []) !== {}) +1672 -> 1674 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1670 -> 1672 member call = ???*0*["charCodeAt"](???*1*) +1674 -> 1676 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1670 -> 1673 conditional = (???*0* === 93) +1674 -> 1677 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1673 -> 1674 conditional = ((0 | ???*0*) === 0) +1677 -> 1678 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1674 -> 1675 call = (...) => undefined( +1678 -> 1679 call = (...) => undefined( {"type": "literal", "text": "]", "ignoreCase": false} ) -1670 -> 1676 conditional = ((???*0* | "]" | {}) !== {}) +1674 -> 1680 conditional = ((???*0* | "]" | {}) !== {}) - *0* s9 ⚠️ pattern without value -1676 -> 1677 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) +1680 -> 1681 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1636 -> 1679 member call = (???*0* | [])["push"](???*1*) +1640 -> 1683 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1636 -> 1680 call = (...) => s0() +1640 -> 1684 call = (...) => s0() -1636 -> 1681 conditional = (???*0* !== {}) +1640 -> 1685 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1681 -> 1683 member call = ???*0*["charCodeAt"](???*1*) +1685 -> 1687 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1681 -> 1684 conditional = (???*0* === 46) +1685 -> 1688 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1684 -> 1685 conditional = ((0 | ???*0*) === 0) +1688 -> 1689 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1685 -> 1686 call = (...) => undefined( +1689 -> 1690 call = (...) => undefined( {"type": "literal", "text": ".", "ignoreCase": false} ) -1681 -> 1687 conditional = ((???*0* | "." | {} | "[") !== {}) +1685 -> 1691 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -1687 -> 1688 call = (...) => s0() +1691 -> 1692 call = (...) => s0() -1687 -> 1689 conditional = ((???*0* | []) !== {}) +1691 -> 1693 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1689 -> 1690 call = (...) => s0() +1693 -> 1694 call = (...) => s0() -1689 -> 1691 conditional = (???*0* !== {}) +1693 -> 1695 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1691 -> 1692 call = (...) => s0() +1695 -> 1696 call = (...) => s0() -1691 -> 1693 conditional = ((???*0* | []) !== {}) +1695 -> 1697 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1693 -> 1694 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) +1697 -> 1698 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1636 -> 1695 conditional = (???*0* === {}) +1640 -> 1699 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1695 -> 1696 call = (...) => s0() +1699 -> 1700 call = (...) => s0() -1695 -> 1697 conditional = (???*0* !== {}) +1699 -> 1701 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1697 -> 1699 member call = ???*0*["charCodeAt"](???*1*) +1701 -> 1703 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1697 -> 1700 conditional = (???*0* === 91) +1701 -> 1704 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1700 -> 1701 conditional = ((0 | ???*0*) === 0) +1704 -> 1705 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1701 -> 1702 call = (...) => undefined( +1705 -> 1706 call = (...) => undefined( {"type": "literal", "text": "[", "ignoreCase": false} ) -1697 -> 1703 conditional = ((???*0* | "." | {} | "[") !== {}) +1701 -> 1707 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -1703 -> 1704 call = (...) => s0() +1707 -> 1708 call = (...) => s0() -1703 -> 1705 conditional = ((???*0* | []) !== {}) +1707 -> 1709 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1705 -> 1706 call = (...) => s0() +1709 -> 1710 call = (...) => s0() -1705 -> 1707 conditional = (???*0* === {}) +1709 -> 1711 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1707 -> 1708 call = (...) => s0() +1711 -> 1712 call = (...) => s0() -1707 -> 1709 conditional = (???*0* === {}) +1711 -> 1713 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1709 -> 1710 call = (...) => s0() +1713 -> 1714 call = (...) => s0() -1705 -> 1711 conditional = (???*0* !== {}) +1709 -> 1715 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1711 -> 1712 call = (...) => s0() +1715 -> 1716 call = (...) => s0() -1711 -> 1713 conditional = ((???*0* | []) !== {}) +1715 -> 1717 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1713 -> 1715 member call = ???*0*["charCodeAt"](???*1*) +1717 -> 1719 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1713 -> 1716 conditional = (???*0* === 93) +1717 -> 1720 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1716 -> 1717 conditional = ((0 | ???*0*) === 0) +1720 -> 1721 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1717 -> 1718 call = (...) => undefined( +1721 -> 1722 call = (...) => undefined( {"type": "literal", "text": "]", "ignoreCase": false} ) -1713 -> 1719 conditional = ((???*0* | "]" | {}) !== {}) +1717 -> 1723 conditional = ((???*0* | "]" | {}) !== {}) - *0* s9 ⚠️ pattern without value -1719 -> 1720 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) +1723 -> 1724 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1636 -> 1721 conditional = ((???*0* | []) !== {}) +1640 -> 1725 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1721 -> 1722 call = (...) => tail["reduce"](*arrow function 13694*, head)(???*0*, (???*1* | [])) +1725 -> 1726 call = (...) => tail["reduce"](*arrow function 13694*, head)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1723 unreachable = ???*0* +0 -> 1727 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1724 call = (...) => s0() +0 -> 1728 call = (...) => s0() -0 -> 1725 conditional = (???*0* === {}) +0 -> 1729 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1725 -> 1726 call = (...) => s0() +1729 -> 1730 call = (...) => s0() -1725 -> 1727 conditional = (???*0* === {}) +1729 -> 1731 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1727 -> 1728 call = (...) => s0() +1731 -> 1732 call = (...) => s0() -1727 -> 1729 conditional = (???*0* !== {}) +1731 -> 1733 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1729 -> 1730 call = (...) => s0() +1733 -> 1734 call = (...) => s0() -1729 -> 1731 conditional = ((???*0* | []) !== {}) +1733 -> 1735 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1731 -> 1732 call = (...) => s0() +1735 -> 1736 call = (...) => s0() -1731 -> 1733 conditional = (???*0* !== {}) +1735 -> 1737 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1733 -> 1734 call = (...) => {"type": "scalar_unary_expression", "operator": operator, "argument": argument}(???*0*, ???*1*) +1737 -> 1738 call = (...) => {"type": "scalar_unary_expression", "operator": operator, "argument": argument}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1735 unreachable = ???*0* +0 -> 1739 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1736 call = (...) => s0() +0 -> 1740 call = (...) => s0() -0 -> 1737 conditional = (???*0* !== {}) +0 -> 1741 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1737 -> 1738 call = (...) => s0() +1741 -> 1742 call = (...) => s0() -1737 -> 1739 conditional = ((???*0* | []) !== {}) +1741 -> 1743 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1739 -> 1741 member call = ???*0*["charCodeAt"](???*1*) +1743 -> 1745 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1739 -> 1742 conditional = (???*0* === 63) +1743 -> 1746 conditional = (???*0* === 63) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1742 -> 1743 conditional = ((0 | ???*0*) === 0) +1746 -> 1747 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1743 -> 1744 call = (...) => undefined( +1747 -> 1748 call = (...) => undefined( {"type": "literal", "text": "?", "ignoreCase": false} ) -1739 -> 1745 conditional = ((???*0* | "?" | {}) !== {}) +1743 -> 1749 conditional = ((???*0* | "?" | {}) !== {}) - *0* s3 ⚠️ pattern without value -1745 -> 1746 call = (...) => s0() +1749 -> 1750 call = (...) => s0() -1745 -> 1747 conditional = ((???*0* | []) !== {}) +1749 -> 1751 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -1747 -> 1748 call = (...) => s0() +1751 -> 1752 call = (...) => s0() -1747 -> 1749 conditional = (???*0* !== {}) +1751 -> 1753 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1749 -> 1750 call = (...) => s0() +1753 -> 1754 call = (...) => s0() -1749 -> 1751 conditional = ((???*0* | []) !== {}) +1753 -> 1755 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1751 -> 1753 member call = ???*0*["charCodeAt"](???*1*) +1755 -> 1757 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1751 -> 1754 conditional = (???*0* === 58) +1755 -> 1758 conditional = (???*0* === 58) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1754 -> 1755 conditional = ((0 | ???*0*) === 0) +1758 -> 1759 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1755 -> 1756 call = (...) => undefined( +1759 -> 1760 call = (...) => undefined( {"type": "literal", "text": ":", "ignoreCase": false} ) -1751 -> 1757 conditional = ((???*0* | ":" | {}) !== {}) +1755 -> 1761 conditional = ((???*0* | ":" | {}) !== {}) - *0* s7 ⚠️ pattern without value -1757 -> 1758 call = (...) => s0() +1761 -> 1762 call = (...) => s0() -1757 -> 1759 conditional = ((???*0* | []) !== {}) +1761 -> 1763 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1759 -> 1760 call = (...) => s0() +1763 -> 1764 call = (...) => s0() -1759 -> 1761 conditional = (???*0* !== {}) +1763 -> 1765 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1761 -> 1762 call = (...) => { +1765 -> 1766 call = (...) => { "type": "scalar_conditional_expression", "test": test, "consequent": consequent, @@ -6481,768 +6481,756 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1763 conditional = (???*0* === {}) +0 -> 1767 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1763 -> 1764 call = (...) => s0() +1767 -> 1768 call = (...) => s0() -0 -> 1765 unreachable = ???*0* +0 -> 1769 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1766 call = (...) => s0() +0 -> 1770 call = (...) => s0() -0 -> 1767 conditional = (???*0* !== {}) +0 -> 1771 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1767 -> 1768 call = (...) => s0() +1771 -> 1772 call = (...) => s0() -1767 -> 1769 conditional = (???*0* !== {}) +1771 -> 1773 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1769 -> 1770 call = (...) => s0() +1773 -> 1774 call = (...) => s0() -1769 -> 1771 conditional = (???*0* === {}) +1773 -> 1775 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1771 -> 1773 member call = ???*0*["substr"](???*1*, 2) +1775 -> 1777 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1771 -> 1774 conditional = (???*0* === "??") +1775 -> 1778 conditional = (???*0* === "??") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1774 -> 1775 conditional = ((0 | ???*0*) === 0) +1778 -> 1779 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1775 -> 1776 call = (...) => undefined( +1779 -> 1780 call = (...) => undefined( {"type": "literal", "text": "??", "ignoreCase": false} ) -1769 -> 1777 conditional = (???*0* !== {}) +1773 -> 1781 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1777 -> 1778 call = (...) => s0() +1781 -> 1782 call = (...) => s0() -1777 -> 1779 conditional = ((???*0* | []) !== {}) +1781 -> 1783 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1779 -> 1780 call = (...) => s0() +1783 -> 1784 call = (...) => s0() -1767 -> 1782 member call = (???*0* | [])["push"](???*1*) +1771 -> 1786 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1767 -> 1783 call = (...) => s0() +1771 -> 1787 call = (...) => s0() -1767 -> 1784 conditional = (???*0* !== {}) +1771 -> 1788 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1784 -> 1785 call = (...) => s0() +1788 -> 1789 call = (...) => s0() -1784 -> 1786 conditional = (???*0* === {}) +1788 -> 1790 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1786 -> 1788 member call = ???*0*["substr"](???*1*, 2) +1790 -> 1792 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1786 -> 1789 conditional = (???*0* === "??") +1790 -> 1793 conditional = (???*0* === "??") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1789 -> 1790 conditional = ((0 | ???*0*) === 0) +1793 -> 1794 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1790 -> 1791 call = (...) => undefined( +1794 -> 1795 call = (...) => undefined( {"type": "literal", "text": "??", "ignoreCase": false} ) -1784 -> 1792 conditional = (???*0* !== {}) +1788 -> 1796 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1792 -> 1793 call = (...) => s0() +1796 -> 1797 call = (...) => s0() -1792 -> 1794 conditional = ((???*0* | []) !== {}) +1796 -> 1798 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1794 -> 1795 call = (...) => s0() +1798 -> 1799 call = (...) => s0() -1767 -> 1796 conditional = ((???*0* | []) !== {}) +1771 -> 1800 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1796 -> 1797 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +1800 -> 1801 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1798 unreachable = ???*0* +0 -> 1802 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1799 call = (...) => s0() +0 -> 1803 call = (...) => s0() -0 -> 1800 conditional = (???*0* !== {}) +0 -> 1804 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1800 -> 1801 call = (...) => s0() +1804 -> 1805 call = (...) => s0() -1800 -> 1802 conditional = (???*0* !== {}) +1804 -> 1806 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1802 -> 1803 call = (...) => s0() +1806 -> 1807 call = (...) => s0() -1802 -> 1804 conditional = (???*0* !== {}) +1806 -> 1808 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1804 -> 1805 call = (...) => s0() +1808 -> 1809 call = (...) => s0() -1804 -> 1806 conditional = ((???*0* | []) !== {}) +1808 -> 1810 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1806 -> 1807 call = (...) => s0() +1810 -> 1811 call = (...) => s0() -1800 -> 1809 member call = (???*0* | [])["push"](???*1*) +1804 -> 1813 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1800 -> 1810 call = (...) => s0() +1804 -> 1814 call = (...) => s0() -1800 -> 1811 conditional = (???*0* !== {}) +1804 -> 1815 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1811 -> 1812 call = (...) => s0() +1815 -> 1816 call = (...) => s0() -1811 -> 1813 conditional = (???*0* !== {}) +1815 -> 1817 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1813 -> 1814 call = (...) => s0() +1817 -> 1818 call = (...) => s0() -1813 -> 1815 conditional = ((???*0* | []) !== {}) +1817 -> 1819 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1815 -> 1816 call = (...) => s0() +1819 -> 1820 call = (...) => s0() -1800 -> 1817 conditional = ((???*0* | []) !== {}) +1804 -> 1821 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1817 -> 1818 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +1821 -> 1822 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1819 unreachable = ???*0* +0 -> 1823 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1820 call = (...) => s0() +0 -> 1824 call = (...) => s0() -0 -> 1821 conditional = (???*0* !== {}) +0 -> 1825 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1821 -> 1822 call = (...) => s0() +1825 -> 1826 call = (...) => s0() -1821 -> 1823 conditional = (???*0* !== {}) +1825 -> 1827 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1823 -> 1825 member call = ???*0*["charCodeAt"](???*1*) +1827 -> 1829 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1823 -> 1826 conditional = (???*0* === 61) +1827 -> 1830 conditional = (???*0* === 61) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1826 -> 1827 conditional = ((0 | ???*0*) === 0) +1830 -> 1831 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1827 -> 1828 call = (...) => undefined( +1831 -> 1832 call = (...) => undefined( {"type": "literal", "text": "=", "ignoreCase": false} ) -1823 -> 1829 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) +1827 -> 1833 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) - *0* s5 ⚠️ pattern without value -1829 -> 1831 member call = ???*0*["substr"](???*1*, 2) +1833 -> 1835 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1829 -> 1832 conditional = (???*0* === "!=") +1833 -> 1836 conditional = (???*0* === "!=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1832 -> 1833 conditional = ((0 | ???*0*) === 0) +1836 -> 1837 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1833 -> 1834 call = (...) => undefined( +1837 -> 1838 call = (...) => undefined( {"type": "literal", "text": "!=", "ignoreCase": false} ) -1829 -> 1835 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) +1833 -> 1839 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) - *0* s5 ⚠️ pattern without value -1835 -> 1837 member call = ???*0*["substr"](???*1*, 2) +1839 -> 1841 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1835 -> 1838 conditional = (???*0* === "<>") +1839 -> 1842 conditional = (???*0* === "<>") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1838 -> 1839 conditional = ((0 | ???*0*) === 0) +1842 -> 1843 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1839 -> 1840 call = (...) => undefined( +1843 -> 1844 call = (...) => undefined( {"type": "literal", "text": "<>", "ignoreCase": false} ) -1823 -> 1841 conditional = ((???*0* | "=" | {} | "!=" | "<>") !== {}) +1827 -> 1845 conditional = ((???*0* | "=" | {} | "!=" | "<>") !== {}) - *0* s5 ⚠️ pattern without value -1841 -> 1842 call = (...) => s0() +1845 -> 1846 call = (...) => s0() -1841 -> 1843 conditional = ((???*0* | []) !== {}) +1845 -> 1847 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1843 -> 1844 call = (...) => s0() +1847 -> 1848 call = (...) => s0() -1821 -> 1846 member call = (???*0* | [])["push"](???*1*) +1825 -> 1850 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1821 -> 1847 call = (...) => s0() +1825 -> 1851 call = (...) => s0() -1821 -> 1848 conditional = (???*0* !== {}) +1825 -> 1852 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1848 -> 1850 member call = ???*0*["charCodeAt"](???*1*) +1852 -> 1854 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1848 -> 1851 conditional = (???*0* === 61) +1852 -> 1855 conditional = (???*0* === 61) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1851 -> 1852 conditional = ((0 | ???*0*) === 0) +1855 -> 1856 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1852 -> 1853 call = (...) => undefined( +1856 -> 1857 call = (...) => undefined( {"type": "literal", "text": "=", "ignoreCase": false} ) -1848 -> 1854 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) +1852 -> 1858 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) - *0* s5 ⚠️ pattern without value -1854 -> 1856 member call = ???*0*["substr"](???*1*, 2) +1858 -> 1860 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1854 -> 1857 conditional = (???*0* === "!=") +1858 -> 1861 conditional = (???*0* === "!=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1857 -> 1858 conditional = ((0 | ???*0*) === 0) +1861 -> 1862 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1858 -> 1859 call = (...) => undefined( +1862 -> 1863 call = (...) => undefined( {"type": "literal", "text": "!=", "ignoreCase": false} ) -1854 -> 1860 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) +1858 -> 1864 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) - *0* s5 ⚠️ pattern without value -1860 -> 1862 member call = ???*0*["substr"](???*1*, 2) +1864 -> 1866 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1860 -> 1863 conditional = (???*0* === "<>") +1864 -> 1867 conditional = (???*0* === "<>") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1863 -> 1864 conditional = ((0 | ???*0*) === 0) +1867 -> 1868 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1864 -> 1865 call = (...) => undefined( +1868 -> 1869 call = (...) => undefined( {"type": "literal", "text": "<>", "ignoreCase": false} ) -1848 -> 1866 conditional = ((???*0* | "=" | {} | "!=" | "<>") !== {}) +1852 -> 1870 conditional = ((???*0* | "=" | {} | "!=" | "<>") !== {}) - *0* s5 ⚠️ pattern without value -1866 -> 1867 call = (...) => s0() +1870 -> 1871 call = (...) => s0() -1866 -> 1868 conditional = ((???*0* | []) !== {}) +1870 -> 1872 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1868 -> 1869 call = (...) => s0() +1872 -> 1873 call = (...) => s0() -1821 -> 1870 conditional = ((???*0* | []) !== {}) +1825 -> 1874 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1870 -> 1871 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +1874 -> 1875 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1872 unreachable = ???*0* +0 -> 1876 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1873 call = (...) => s0() +0 -> 1877 call = (...) => s0() -0 -> 1874 conditional = (???*0* !== {}) +0 -> 1878 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1874 -> 1875 call = (...) => s0() +1878 -> 1879 call = (...) => s0() -1874 -> 1876 conditional = (???*0* !== {}) +1878 -> 1880 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1876 -> 1878 member call = ???*0*["substr"](???*1*, 2) +1880 -> 1882 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1876 -> 1879 conditional = (???*0* === "<=") +1880 -> 1883 conditional = (???*0* === "<=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1879 -> 1880 conditional = ((0 | ???*0*) === 0) +1883 -> 1884 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1880 -> 1881 call = (...) => undefined( +1884 -> 1885 call = (...) => undefined( {"type": "literal", "text": "<=", "ignoreCase": false} ) -1876 -> 1882 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1880 -> 1886 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1882 -> 1884 member call = ???*0*["substr"](???*1*, 2) +1886 -> 1888 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1882 -> 1885 conditional = (???*0* === ">=") +1886 -> 1889 conditional = (???*0* === ">=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1885 -> 1886 conditional = ((0 | ???*0*) === 0) +1889 -> 1890 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1886 -> 1887 call = (...) => undefined( +1890 -> 1891 call = (...) => undefined( {"type": "literal", "text": ">=", "ignoreCase": false} ) -1882 -> 1888 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1886 -> 1892 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1888 -> 1890 member call = ???*0*["charCodeAt"](???*1*) +1892 -> 1894 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1888 -> 1891 conditional = (???*0* === 60) +1892 -> 1895 conditional = (???*0* === 60) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1891 -> 1892 conditional = ((0 | ???*0*) === 0) +1895 -> 1896 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1892 -> 1893 call = (...) => undefined( +1896 -> 1897 call = (...) => undefined( {"type": "literal", "text": "<", "ignoreCase": false} ) -1888 -> 1894 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1892 -> 1898 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1894 -> 1896 member call = ???*0*["charCodeAt"](???*1*) +1898 -> 1900 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1894 -> 1897 conditional = (???*0* === 62) +1898 -> 1901 conditional = (???*0* === 62) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1897 -> 1898 conditional = ((0 | ???*0*) === 0) +1901 -> 1902 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1898 -> 1899 call = (...) => undefined( +1902 -> 1903 call = (...) => undefined( {"type": "literal", "text": ">", "ignoreCase": false} ) -1876 -> 1900 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") !== {}) +1880 -> 1904 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") !== {}) - *0* s5 ⚠️ pattern without value -1900 -> 1901 call = (...) => s0() +1904 -> 1905 call = (...) => s0() -1900 -> 1902 conditional = ((???*0* | []) !== {}) +1904 -> 1906 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1902 -> 1903 call = (...) => s0() +1906 -> 1907 call = (...) => s0() -1874 -> 1905 member call = (???*0* | [])["push"](???*1*) +1878 -> 1909 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1874 -> 1906 call = (...) => s0() +1878 -> 1910 call = (...) => s0() -1874 -> 1907 conditional = (???*0* !== {}) +1878 -> 1911 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1907 -> 1909 member call = ???*0*["substr"](???*1*, 2) +1911 -> 1913 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1907 -> 1910 conditional = (???*0* === "<=") +1911 -> 1914 conditional = (???*0* === "<=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1910 -> 1911 conditional = ((0 | ???*0*) === 0) +1914 -> 1915 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1911 -> 1912 call = (...) => undefined( +1915 -> 1916 call = (...) => undefined( {"type": "literal", "text": "<=", "ignoreCase": false} ) -1907 -> 1913 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1911 -> 1917 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1913 -> 1915 member call = ???*0*["substr"](???*1*, 2) +1917 -> 1919 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1913 -> 1916 conditional = (???*0* === ">=") +1917 -> 1920 conditional = (???*0* === ">=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1916 -> 1917 conditional = ((0 | ???*0*) === 0) +1920 -> 1921 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1917 -> 1918 call = (...) => undefined( +1921 -> 1922 call = (...) => undefined( {"type": "literal", "text": ">=", "ignoreCase": false} ) -1913 -> 1919 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1917 -> 1923 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1919 -> 1921 member call = ???*0*["charCodeAt"](???*1*) +1923 -> 1925 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1919 -> 1922 conditional = (???*0* === 60) +1923 -> 1926 conditional = (???*0* === 60) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1922 -> 1923 conditional = ((0 | ???*0*) === 0) +1926 -> 1927 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1923 -> 1924 call = (...) => undefined( +1927 -> 1928 call = (...) => undefined( {"type": "literal", "text": "<", "ignoreCase": false} ) -1919 -> 1925 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1923 -> 1929 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1925 -> 1927 member call = ???*0*["charCodeAt"](???*1*) +1929 -> 1931 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1925 -> 1928 conditional = (???*0* === 62) +1929 -> 1932 conditional = (???*0* === 62) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1928 -> 1929 conditional = ((0 | ???*0*) === 0) +1932 -> 1933 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1929 -> 1930 call = (...) => undefined( +1933 -> 1934 call = (...) => undefined( {"type": "literal", "text": ">", "ignoreCase": false} ) -1907 -> 1931 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") !== {}) +1911 -> 1935 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") !== {}) - *0* s5 ⚠️ pattern without value -1931 -> 1932 call = (...) => s0() +1935 -> 1936 call = (...) => s0() -1931 -> 1933 conditional = ((???*0* | []) !== {}) +1935 -> 1937 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1933 -> 1934 call = (...) => s0() +1937 -> 1938 call = (...) => s0() -1874 -> 1935 conditional = ((???*0* | []) !== {}) +1878 -> 1939 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1935 -> 1936 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +1939 -> 1940 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1937 unreachable = ???*0* +0 -> 1941 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1938 call = (...) => s0() +0 -> 1942 call = (...) => s0() -0 -> 1939 conditional = (???*0* !== {}) +0 -> 1943 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1939 -> 1940 call = (...) => s0() +1943 -> 1944 call = (...) => s0() -1939 -> 1941 conditional = ((???*0* | []) !== {}) +1943 -> 1945 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1941 -> 1942 call = (...) => s0() +1945 -> 1946 call = (...) => s0() -1941 -> 1943 conditional = (???*0* !== {}) +1945 -> 1947 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1943 -> 1944 call = (...) => s0() +1947 -> 1948 call = (...) => s0() -1943 -> 1945 conditional = ((???*0* | []) !== {}) +1947 -> 1949 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -1945 -> 1947 member call = ???*0*["charCodeAt"](???*1*) +1949 -> 1951 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1945 -> 1948 conditional = (???*0* === 40) +1949 -> 1952 conditional = (???*0* === 40) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1948 -> 1949 conditional = ((0 | ???*0*) === 0) +1952 -> 1953 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1949 -> 1950 call = (...) => undefined( +1953 -> 1954 call = (...) => undefined( {"type": "literal", "text": "(", "ignoreCase": false} ) -1945 -> 1951 conditional = ((???*0* | "(" | {}) !== {}) +1949 -> 1955 conditional = ((???*0* | "(" | {}) !== {}) - *0* s5 ⚠️ pattern without value -1951 -> 1952 call = (...) => s0() +1955 -> 1956 call = (...) => s0() -1951 -> 1953 conditional = ((???*0* | []) !== {}) +1955 -> 1957 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1953 -> 1954 call = (...) => s0() +1957 -> 1958 call = (...) => s0() -1953 -> 1955 conditional = (???*0* !== {}) +1957 -> 1959 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1955 -> 1956 call = (...) => s0() +1959 -> 1960 call = (...) => s0() -1955 -> 1957 conditional = ((???*0* | []) !== {}) +1959 -> 1961 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1957 -> 1959 member call = ???*0*["charCodeAt"](???*1*) +1961 -> 1963 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1957 -> 1960 conditional = (???*0* === 41) +1961 -> 1964 conditional = (???*0* === 41) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1960 -> 1961 conditional = ((0 | ???*0*) === 0) +1964 -> 1965 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1961 -> 1962 call = (...) => undefined( +1965 -> 1966 call = (...) => undefined( {"type": "literal", "text": ")", "ignoreCase": false} ) -1957 -> 1963 conditional = ((???*0* | ")" | {}) !== {}) +1961 -> 1967 conditional = ((???*0* | ")" | {}) !== {}) - *0* s9 ⚠️ pattern without value -1963 -> 1964 call = (...) => {"type": "scalar_in_expression", "value": value, "list": list}(???*0*, ???*1*) +1967 -> 1968 call = (...) => {"type": "scalar_in_expression", "value": value, "list": list}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1965 conditional = (???*0* === {}) +0 -> 1969 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1965 -> 1966 call = (...) => s0() +1969 -> 1970 call = (...) => s0() -0 -> 1967 unreachable = ???*0* +0 -> 1971 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1968 call = (...) => s0() +0 -> 1972 call = (...) => s0() -0 -> 1969 conditional = (???*0* !== {}) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -1969 -> 1970 call = (...) => s0() - -1969 -> 1971 conditional = ((???*0* | []) !== {}) -- *0* s2 - ⚠️ pattern without value - -1971 -> 1972 call = (...) => s0() - -1971 -> 1973 conditional = (???*0* !== {}) +0 -> 1973 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects 1973 -> 1974 call = (...) => s0() 1973 -> 1975 conditional = ((???*0* | []) !== {}) -- *0* s4 +- *0* s2 ⚠️ pattern without value 1975 -> 1976 call = (...) => s0() @@ -7254,7 +7242,7 @@ 1977 -> 1978 call = (...) => s0() 1977 -> 1979 conditional = ((???*0* | []) !== {}) -- *0* s6 +- *0* s4 ⚠️ pattern without value 1979 -> 1980 call = (...) => s0() @@ -7266,7 +7254,7 @@ 1981 -> 1982 call = (...) => s0() 1981 -> 1983 conditional = ((???*0* | []) !== {}) -- *0* s8 +- *0* s6 ⚠️ pattern without value 1983 -> 1984 call = (...) => s0() @@ -7275,7 +7263,19 @@ - *0* max number of linking steps reached ⚠️ This value might have side effects -1985 -> 1986 call = (...) => {"type": "scalar_between_expression", "value": value, "begin": begin, "end": end}(???*0*, ???*1*, ???*2*) +1985 -> 1986 call = (...) => s0() + +1985 -> 1987 conditional = ((???*0* | []) !== {}) +- *0* s8 + ⚠️ pattern without value + +1987 -> 1988 call = (...) => s0() + +1987 -> 1989 conditional = (???*0* !== {}) +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +1989 -> 1990 call = (...) => {"type": "scalar_between_expression", "value": value, "begin": begin, "end": end}(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -7283,1451 +7283,1451 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1987 conditional = (???*0* === {}) +0 -> 1991 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1987 -> 1988 call = (...) => s0() +1991 -> 1992 call = (...) => s0() -0 -> 1989 unreachable = ???*0* +0 -> 1993 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 1990 call = (...) => s0() +0 -> 1994 call = (...) => s0() -0 -> 1991 conditional = (???*0* !== {}) +0 -> 1995 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1991 -> 1992 call = (...) => s0() +1995 -> 1996 call = (...) => s0() -1991 -> 1993 conditional = (???*0* !== {}) +1995 -> 1997 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -1993 -> 1995 member call = ???*0*["charCodeAt"](???*1*) +1997 -> 1999 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1993 -> 1996 conditional = (???*0* === 124) +1997 -> 2000 conditional = (???*0* === 124) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -1996 -> 1997 conditional = ((0 | ???*0*) === 0) +2000 -> 2001 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1997 -> 1998 call = (...) => undefined( +2001 -> 2002 call = (...) => undefined( {"type": "literal", "text": "|", "ignoreCase": false} ) -1993 -> 1999 conditional = ((???*0* | "|" | {}) !== {}) +1997 -> 2003 conditional = ((???*0* | "|" | {}) !== {}) - *0* s5 ⚠️ pattern without value -1999 -> 2000 call = (...) => s0() +2003 -> 2004 call = (...) => s0() -1999 -> 2001 conditional = ((???*0* | []) !== {}) +2003 -> 2005 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2001 -> 2002 call = (...) => s0() +2005 -> 2006 call = (...) => s0() -1991 -> 2004 member call = (???*0* | [])["push"](???*1*) +1995 -> 2008 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1991 -> 2005 call = (...) => s0() +1995 -> 2009 call = (...) => s0() -1991 -> 2006 conditional = (???*0* !== {}) +1995 -> 2010 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2006 -> 2008 member call = ???*0*["charCodeAt"](???*1*) +2010 -> 2012 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2006 -> 2009 conditional = (???*0* === 124) +2010 -> 2013 conditional = (???*0* === 124) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2009 -> 2010 conditional = ((0 | ???*0*) === 0) +2013 -> 2014 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2010 -> 2011 call = (...) => undefined( +2014 -> 2015 call = (...) => undefined( {"type": "literal", "text": "|", "ignoreCase": false} ) -2006 -> 2012 conditional = ((???*0* | "|" | {}) !== {}) +2010 -> 2016 conditional = ((???*0* | "|" | {}) !== {}) - *0* s5 ⚠️ pattern without value -2012 -> 2013 call = (...) => s0() +2016 -> 2017 call = (...) => s0() -2012 -> 2014 conditional = ((???*0* | []) !== {}) +2016 -> 2018 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2014 -> 2015 call = (...) => s0() +2018 -> 2019 call = (...) => s0() -1991 -> 2016 conditional = ((???*0* | []) !== {}) +1995 -> 2020 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2016 -> 2017 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2020 -> 2021 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 2018 unreachable = ???*0* +0 -> 2022 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2019 call = (...) => s0() +0 -> 2023 call = (...) => s0() -0 -> 2020 conditional = (???*0* !== {}) +0 -> 2024 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2020 -> 2021 call = (...) => s0() +2024 -> 2025 call = (...) => s0() -2020 -> 2022 conditional = (???*0* !== {}) +2024 -> 2026 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2022 -> 2024 member call = ???*0*["charCodeAt"](???*1*) +2026 -> 2028 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2022 -> 2025 conditional = (???*0* === 94) +2026 -> 2029 conditional = (???*0* === 94) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2025 -> 2026 conditional = ((0 | ???*0*) === 0) +2029 -> 2030 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2026 -> 2027 call = (...) => undefined( +2030 -> 2031 call = (...) => undefined( {"type": "literal", "text": "^", "ignoreCase": false} ) -2022 -> 2028 conditional = ((???*0* | "^" | {}) !== {}) +2026 -> 2032 conditional = ((???*0* | "^" | {}) !== {}) - *0* s5 ⚠️ pattern without value -2028 -> 2029 call = (...) => s0() +2032 -> 2033 call = (...) => s0() -2028 -> 2030 conditional = ((???*0* | []) !== {}) +2032 -> 2034 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2030 -> 2031 call = (...) => s0() +2034 -> 2035 call = (...) => s0() -2020 -> 2033 member call = (???*0* | [])["push"](???*1*) +2024 -> 2037 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -2020 -> 2034 call = (...) => s0() +2024 -> 2038 call = (...) => s0() -2020 -> 2035 conditional = (???*0* !== {}) +2024 -> 2039 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2035 -> 2037 member call = ???*0*["charCodeAt"](???*1*) +2039 -> 2041 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2035 -> 2038 conditional = (???*0* === 94) +2039 -> 2042 conditional = (???*0* === 94) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2038 -> 2039 conditional = ((0 | ???*0*) === 0) +2042 -> 2043 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2039 -> 2040 call = (...) => undefined( +2043 -> 2044 call = (...) => undefined( {"type": "literal", "text": "^", "ignoreCase": false} ) -2035 -> 2041 conditional = ((???*0* | "^" | {}) !== {}) +2039 -> 2045 conditional = ((???*0* | "^" | {}) !== {}) - *0* s5 ⚠️ pattern without value -2041 -> 2042 call = (...) => s0() +2045 -> 2046 call = (...) => s0() -2041 -> 2043 conditional = ((???*0* | []) !== {}) +2045 -> 2047 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2043 -> 2044 call = (...) => s0() +2047 -> 2048 call = (...) => s0() -2020 -> 2045 conditional = ((???*0* | []) !== {}) +2024 -> 2049 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2045 -> 2046 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2049 -> 2050 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 2047 unreachable = ???*0* +0 -> 2051 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2048 call = (...) => s0() +0 -> 2052 call = (...) => s0() -0 -> 2049 conditional = (???*0* !== {}) +0 -> 2053 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2049 -> 2050 call = (...) => s0() +2053 -> 2054 call = (...) => s0() -2049 -> 2051 conditional = (???*0* !== {}) +2053 -> 2055 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2051 -> 2053 member call = ???*0*["charCodeAt"](???*1*) +2055 -> 2057 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2051 -> 2054 conditional = (???*0* === 38) +2055 -> 2058 conditional = (???*0* === 38) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2054 -> 2055 conditional = ((0 | ???*0*) === 0) +2058 -> 2059 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2055 -> 2056 call = (...) => undefined( +2059 -> 2060 call = (...) => undefined( {"type": "literal", "text": "&", "ignoreCase": false} ) -2051 -> 2057 conditional = ((???*0* | "&" | {}) !== {}) +2055 -> 2061 conditional = ((???*0* | "&" | {}) !== {}) - *0* s5 ⚠️ pattern without value -2057 -> 2058 call = (...) => s0() +2061 -> 2062 call = (...) => s0() -2057 -> 2059 conditional = ((???*0* | []) !== {}) +2061 -> 2063 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2059 -> 2060 call = (...) => s0() +2063 -> 2064 call = (...) => s0() -2049 -> 2062 member call = (???*0* | [])["push"](???*1*) +2053 -> 2066 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -2049 -> 2063 call = (...) => s0() +2053 -> 2067 call = (...) => s0() -2049 -> 2064 conditional = (???*0* !== {}) +2053 -> 2068 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2064 -> 2066 member call = ???*0*["charCodeAt"](???*1*) +2068 -> 2070 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2064 -> 2067 conditional = (???*0* === 38) +2068 -> 2071 conditional = (???*0* === 38) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2067 -> 2068 conditional = ((0 | ???*0*) === 0) +2071 -> 2072 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2068 -> 2069 call = (...) => undefined( +2072 -> 2073 call = (...) => undefined( {"type": "literal", "text": "&", "ignoreCase": false} ) -2064 -> 2070 conditional = ((???*0* | "&" | {}) !== {}) +2068 -> 2074 conditional = ((???*0* | "&" | {}) !== {}) - *0* s5 ⚠️ pattern without value -2070 -> 2071 call = (...) => s0() +2074 -> 2075 call = (...) => s0() -2070 -> 2072 conditional = ((???*0* | []) !== {}) +2074 -> 2076 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2072 -> 2073 call = (...) => s0() +2076 -> 2077 call = (...) => s0() -2049 -> 2074 conditional = ((???*0* | []) !== {}) +2053 -> 2078 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2074 -> 2075 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2078 -> 2079 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 2076 unreachable = ???*0* +0 -> 2080 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2077 call = (...) => s0() +0 -> 2081 call = (...) => s0() -0 -> 2078 conditional = (???*0* !== {}) +0 -> 2082 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2078 -> 2079 call = (...) => s0() +2082 -> 2083 call = (...) => s0() -2078 -> 2080 conditional = (???*0* !== {}) +2082 -> 2084 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2080 -> 2082 member call = ???*0*["substr"](???*1*, 2) +2084 -> 2086 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2080 -> 2083 conditional = (???*0* === "<<") +2084 -> 2087 conditional = (???*0* === "<<") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2083 -> 2084 conditional = ((0 | ???*0*) === 0) +2087 -> 2088 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2084 -> 2085 call = (...) => undefined( +2088 -> 2089 call = (...) => undefined( {"type": "literal", "text": "<<", "ignoreCase": false} ) -2080 -> 2086 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) +2084 -> 2090 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) - *0* s5 ⚠️ pattern without value -2086 -> 2088 member call = ???*0*["substr"](???*1*, 3) +2090 -> 2092 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2086 -> 2089 conditional = (???*0* === ">>>") +2090 -> 2093 conditional = (???*0* === ">>>") - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2089 -> 2090 conditional = ((0 | ???*0*) === 0) +2093 -> 2094 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2090 -> 2091 call = (...) => undefined( +2094 -> 2095 call = (...) => undefined( {"type": "literal", "text": ">>>", "ignoreCase": false} ) -2086 -> 2092 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) +2090 -> 2096 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) - *0* s5 ⚠️ pattern without value -2092 -> 2094 member call = ???*0*["substr"](???*1*, 2) +2096 -> 2098 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2092 -> 2095 conditional = (???*0* === ">>") +2096 -> 2099 conditional = (???*0* === ">>") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2095 -> 2096 conditional = ((0 | ???*0*) === 0) +2099 -> 2100 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2096 -> 2097 call = (...) => undefined( +2100 -> 2101 call = (...) => undefined( {"type": "literal", "text": ">>", "ignoreCase": false} ) -2080 -> 2098 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") !== {}) +2084 -> 2102 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") !== {}) - *0* s5 ⚠️ pattern without value -2098 -> 2099 call = (...) => s0() +2102 -> 2103 call = (...) => s0() -2098 -> 2100 conditional = ((???*0* | []) !== {}) +2102 -> 2104 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2100 -> 2101 call = (...) => s0() +2104 -> 2105 call = (...) => s0() -2078 -> 2103 member call = (???*0* | [])["push"](???*1*) +2082 -> 2107 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -2078 -> 2104 call = (...) => s0() +2082 -> 2108 call = (...) => s0() -2078 -> 2105 conditional = (???*0* !== {}) +2082 -> 2109 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2105 -> 2107 member call = ???*0*["substr"](???*1*, 2) +2109 -> 2111 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2105 -> 2108 conditional = (???*0* === "<<") +2109 -> 2112 conditional = (???*0* === "<<") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2108 -> 2109 conditional = ((0 | ???*0*) === 0) +2112 -> 2113 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2109 -> 2110 call = (...) => undefined( +2113 -> 2114 call = (...) => undefined( {"type": "literal", "text": "<<", "ignoreCase": false} ) -2105 -> 2111 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) +2109 -> 2115 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) - *0* s5 ⚠️ pattern without value -2111 -> 2113 member call = ???*0*["substr"](???*1*, 3) +2115 -> 2117 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2111 -> 2114 conditional = (???*0* === ">>>") +2115 -> 2118 conditional = (???*0* === ">>>") - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2114 -> 2115 conditional = ((0 | ???*0*) === 0) +2118 -> 2119 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2115 -> 2116 call = (...) => undefined( +2119 -> 2120 call = (...) => undefined( {"type": "literal", "text": ">>>", "ignoreCase": false} ) -2111 -> 2117 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) +2115 -> 2121 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) - *0* s5 ⚠️ pattern without value -2117 -> 2119 member call = ???*0*["substr"](???*1*, 2) +2121 -> 2123 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2117 -> 2120 conditional = (???*0* === ">>") +2121 -> 2124 conditional = (???*0* === ">>") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2120 -> 2121 conditional = ((0 | ???*0*) === 0) +2124 -> 2125 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2121 -> 2122 call = (...) => undefined( +2125 -> 2126 call = (...) => undefined( {"type": "literal", "text": ">>", "ignoreCase": false} ) -2105 -> 2123 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") !== {}) +2109 -> 2127 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") !== {}) - *0* s5 ⚠️ pattern without value -2123 -> 2124 call = (...) => s0() +2127 -> 2128 call = (...) => s0() -2123 -> 2125 conditional = ((???*0* | []) !== {}) +2127 -> 2129 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2125 -> 2126 call = (...) => s0() +2129 -> 2130 call = (...) => s0() -2078 -> 2127 conditional = ((???*0* | []) !== {}) +2082 -> 2131 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2127 -> 2128 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2131 -> 2132 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 2129 unreachable = ???*0* +0 -> 2133 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2130 call = (...) => s0() +0 -> 2134 call = (...) => s0() -0 -> 2131 conditional = (???*0* !== {}) +0 -> 2135 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2131 -> 2132 call = (...) => s0() +2135 -> 2136 call = (...) => s0() -2131 -> 2133 conditional = (???*0* !== {}) +2135 -> 2137 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2133 -> 2135 member call = ???*0*["charCodeAt"](???*1*) +2137 -> 2139 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2133 -> 2136 conditional = (???*0* === 43) +2137 -> 2140 conditional = (???*0* === 43) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2136 -> 2137 conditional = ((0 | ???*0*) === 0) +2140 -> 2141 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2137 -> 2138 call = (...) => undefined( +2141 -> 2142 call = (...) => undefined( {"type": "literal", "text": "+", "ignoreCase": false} ) -2133 -> 2139 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) +2137 -> 2143 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) - *0* s5 ⚠️ pattern without value -2139 -> 2141 member call = ???*0*["charCodeAt"](???*1*) +2143 -> 2145 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2139 -> 2142 conditional = (???*0* === 45) +2143 -> 2146 conditional = (???*0* === 45) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2142 -> 2143 conditional = ((0 | ???*0*) === 0) +2146 -> 2147 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2143 -> 2144 call = (...) => undefined( +2147 -> 2148 call = (...) => undefined( {"type": "literal", "text": "-", "ignoreCase": false} ) -2139 -> 2145 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) +2143 -> 2149 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) - *0* s5 ⚠️ pattern without value -2145 -> 2147 member call = ???*0*["substr"](???*1*, 2) +2149 -> 2151 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2145 -> 2148 conditional = (???*0* === "||") +2149 -> 2152 conditional = (???*0* === "||") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2148 -> 2149 conditional = ((0 | ???*0*) === 0) +2152 -> 2153 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2149 -> 2150 call = (...) => undefined( +2153 -> 2154 call = (...) => undefined( {"type": "literal", "text": "||", "ignoreCase": false} ) -2133 -> 2151 conditional = ((???*0* | "+" | {} | "-" | "||") !== {}) +2137 -> 2155 conditional = ((???*0* | "+" | {} | "-" | "||") !== {}) - *0* s5 ⚠️ pattern without value -2151 -> 2152 call = (...) => s0() +2155 -> 2156 call = (...) => s0() -2151 -> 2153 conditional = ((???*0* | []) !== {}) +2155 -> 2157 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2153 -> 2154 call = (...) => s0() +2157 -> 2158 call = (...) => s0() -2131 -> 2156 member call = (???*0* | [])["push"](???*1*) +2135 -> 2160 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -2131 -> 2157 call = (...) => s0() +2135 -> 2161 call = (...) => s0() -2131 -> 2158 conditional = (???*0* !== {}) +2135 -> 2162 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2158 -> 2160 member call = ???*0*["charCodeAt"](???*1*) +2162 -> 2164 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2158 -> 2161 conditional = (???*0* === 43) +2162 -> 2165 conditional = (???*0* === 43) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2161 -> 2162 conditional = ((0 | ???*0*) === 0) +2165 -> 2166 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2162 -> 2163 call = (...) => undefined( +2166 -> 2167 call = (...) => undefined( {"type": "literal", "text": "+", "ignoreCase": false} ) -2158 -> 2164 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) +2162 -> 2168 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) - *0* s5 ⚠️ pattern without value -2164 -> 2166 member call = ???*0*["charCodeAt"](???*1*) +2168 -> 2170 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2164 -> 2167 conditional = (???*0* === 45) +2168 -> 2171 conditional = (???*0* === 45) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2167 -> 2168 conditional = ((0 | ???*0*) === 0) +2171 -> 2172 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2168 -> 2169 call = (...) => undefined( +2172 -> 2173 call = (...) => undefined( {"type": "literal", "text": "-", "ignoreCase": false} ) -2164 -> 2170 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) +2168 -> 2174 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) - *0* s5 ⚠️ pattern without value -2170 -> 2172 member call = ???*0*["substr"](???*1*, 2) +2174 -> 2176 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2170 -> 2173 conditional = (???*0* === "||") +2174 -> 2177 conditional = (???*0* === "||") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2173 -> 2174 conditional = ((0 | ???*0*) === 0) +2177 -> 2178 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2174 -> 2175 call = (...) => undefined( +2178 -> 2179 call = (...) => undefined( {"type": "literal", "text": "||", "ignoreCase": false} ) -2158 -> 2176 conditional = ((???*0* | "+" | {} | "-" | "||") !== {}) +2162 -> 2180 conditional = ((???*0* | "+" | {} | "-" | "||") !== {}) - *0* s5 ⚠️ pattern without value -2176 -> 2177 call = (...) => s0() +2180 -> 2181 call = (...) => s0() -2176 -> 2178 conditional = ((???*0* | []) !== {}) +2180 -> 2182 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2178 -> 2179 call = (...) => s0() +2182 -> 2183 call = (...) => s0() -2131 -> 2180 conditional = ((???*0* | []) !== {}) +2135 -> 2184 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2180 -> 2181 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2184 -> 2185 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 2182 unreachable = ???*0* +0 -> 2186 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2183 call = (...) => s0() +0 -> 2187 call = (...) => s0() -0 -> 2184 conditional = (???*0* !== {}) +0 -> 2188 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2184 -> 2185 call = (...) => s0() +2188 -> 2189 call = (...) => s0() -2184 -> 2186 conditional = (???*0* !== {}) +2188 -> 2190 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2186 -> 2188 member call = ???*0*["charCodeAt"](???*1*) +2190 -> 2192 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2186 -> 2189 conditional = (???*0* === 42) +2190 -> 2193 conditional = (???*0* === 42) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2189 -> 2190 conditional = ((0 | ???*0*) === 0) +2193 -> 2194 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2190 -> 2191 call = (...) => undefined( +2194 -> 2195 call = (...) => undefined( {"type": "literal", "text": "*", "ignoreCase": false} ) -2186 -> 2192 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) +2190 -> 2196 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) - *0* s5 ⚠️ pattern without value -2192 -> 2194 member call = ???*0*["charCodeAt"](???*1*) +2196 -> 2198 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2192 -> 2195 conditional = (???*0* === 47) +2196 -> 2199 conditional = (???*0* === 47) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2195 -> 2196 conditional = ((0 | ???*0*) === 0) +2199 -> 2200 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2196 -> 2197 call = (...) => undefined( +2200 -> 2201 call = (...) => undefined( {"type": "literal", "text": "/", "ignoreCase": false} ) -2192 -> 2198 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) +2196 -> 2202 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) - *0* s5 ⚠️ pattern without value -2198 -> 2200 member call = ???*0*["charCodeAt"](???*1*) +2202 -> 2204 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2198 -> 2201 conditional = (???*0* === 37) +2202 -> 2205 conditional = (???*0* === 37) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2201 -> 2202 conditional = ((0 | ???*0*) === 0) +2205 -> 2206 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2202 -> 2203 call = (...) => undefined( +2206 -> 2207 call = (...) => undefined( {"type": "literal", "text": "%", "ignoreCase": false} ) -2186 -> 2204 conditional = ((???*0* | "*" | {} | "/" | "%") !== {}) +2190 -> 2208 conditional = ((???*0* | "*" | {} | "/" | "%") !== {}) - *0* s5 ⚠️ pattern without value -2204 -> 2205 call = (...) => s0() +2208 -> 2209 call = (...) => s0() -2204 -> 2206 conditional = ((???*0* | []) !== {}) +2208 -> 2210 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2206 -> 2207 call = (...) => s0() +2210 -> 2211 call = (...) => s0() -2184 -> 2209 member call = (???*0* | [])["push"](???*1*) +2188 -> 2213 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -2184 -> 2210 call = (...) => s0() +2188 -> 2214 call = (...) => s0() -2184 -> 2211 conditional = (???*0* !== {}) +2188 -> 2215 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2211 -> 2213 member call = ???*0*["charCodeAt"](???*1*) +2215 -> 2217 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2211 -> 2214 conditional = (???*0* === 42) +2215 -> 2218 conditional = (???*0* === 42) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2214 -> 2215 conditional = ((0 | ???*0*) === 0) +2218 -> 2219 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2215 -> 2216 call = (...) => undefined( +2219 -> 2220 call = (...) => undefined( {"type": "literal", "text": "*", "ignoreCase": false} ) -2211 -> 2217 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) +2215 -> 2221 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) - *0* s5 ⚠️ pattern without value -2217 -> 2219 member call = ???*0*["charCodeAt"](???*1*) +2221 -> 2223 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2217 -> 2220 conditional = (???*0* === 47) +2221 -> 2224 conditional = (???*0* === 47) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2220 -> 2221 conditional = ((0 | ???*0*) === 0) +2224 -> 2225 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2221 -> 2222 call = (...) => undefined( +2225 -> 2226 call = (...) => undefined( {"type": "literal", "text": "/", "ignoreCase": false} ) -2217 -> 2223 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) +2221 -> 2227 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) - *0* s5 ⚠️ pattern without value -2223 -> 2225 member call = ???*0*["charCodeAt"](???*1*) +2227 -> 2229 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2223 -> 2226 conditional = (???*0* === 37) +2227 -> 2230 conditional = (???*0* === 37) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2226 -> 2227 conditional = ((0 | ???*0*) === 0) +2230 -> 2231 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2227 -> 2228 call = (...) => undefined( +2231 -> 2232 call = (...) => undefined( {"type": "literal", "text": "%", "ignoreCase": false} ) -2211 -> 2229 conditional = ((???*0* | "*" | {} | "/" | "%") !== {}) +2215 -> 2233 conditional = ((???*0* | "*" | {} | "/" | "%") !== {}) - *0* s5 ⚠️ pattern without value -2229 -> 2230 call = (...) => s0() +2233 -> 2234 call = (...) => s0() -2229 -> 2231 conditional = ((???*0* | []) !== {}) +2233 -> 2235 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2231 -> 2232 call = (...) => s0() +2235 -> 2236 call = (...) => s0() -2184 -> 2233 conditional = ((???*0* | []) !== {}) +2188 -> 2237 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2233 -> 2234 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2237 -> 2238 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 2235 unreachable = ???*0* +0 -> 2239 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2236 call = (...) => s0() +0 -> 2240 call = (...) => s0() -0 -> 2237 conditional = (???*0* === {}) +0 -> 2241 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2237 -> 2238 call = (...) => s0() +2241 -> 2242 call = (...) => s0() -0 -> 2239 conditional = (???*0* !== {}) +0 -> 2243 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2239 -> 2240 call = (...) => s0() +2243 -> 2244 call = (...) => s0() -2239 -> 2241 conditional = ((???*0* | []) !== {}) +2243 -> 2245 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2241 -> 2243 member call = ???*0*["charCodeAt"](???*1*) +2245 -> 2247 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2241 -> 2244 conditional = (???*0* === 58) +2245 -> 2248 conditional = (???*0* === 58) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2244 -> 2245 conditional = ((0 | ???*0*) === 0) +2248 -> 2249 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2245 -> 2246 call = (...) => undefined( +2249 -> 2250 call = (...) => undefined( {"type": "literal", "text": ":", "ignoreCase": false} ) -2241 -> 2247 conditional = ((???*0* | ":" | {}) !== {}) +2245 -> 2251 conditional = ((???*0* | ":" | {}) !== {}) - *0* s3 ⚠️ pattern without value -2247 -> 2248 call = (...) => s0() +2251 -> 2252 call = (...) => s0() -2247 -> 2249 conditional = ((???*0* | []) !== {}) +2251 -> 2253 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -2249 -> 2250 call = (...) => s0() +2253 -> 2254 call = (...) => s0() -2249 -> 2251 conditional = (???*0* !== {}) +2253 -> 2255 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2251 -> 2252 call = (...) => {"key": key, "value": value}(???*0*, ???*1*) +2255 -> 2256 call = (...) => {"key": key, "value": value}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2253 unreachable = ???*0* +0 -> 2257 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2254 call = (...) => s0() +0 -> 2258 call = (...) => s0() -0 -> 2255 conditional = (???*0* === {}) +0 -> 2259 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2255 -> 2256 call = (...) => s0() +2259 -> 2260 call = (...) => s0() -0 -> 2257 conditional = (???*0* !== {}) +0 -> 2261 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2257 -> 2258 call = (...) => s0() +2261 -> 2262 call = (...) => s0() -2257 -> 2259 conditional = ((???*0* | []) !== {}) +2261 -> 2263 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2259 -> 2261 member call = ???*0*["charCodeAt"](???*1*) +2263 -> 2265 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2259 -> 2262 conditional = (???*0* === 58) +2263 -> 2266 conditional = (???*0* === 58) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2262 -> 2263 conditional = ((0 | ???*0*) === 0) +2266 -> 2267 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2263 -> 2264 call = (...) => undefined( +2267 -> 2268 call = (...) => undefined( {"type": "literal", "text": ":", "ignoreCase": false} ) -2259 -> 2265 conditional = ((???*0* | ":" | {}) !== {}) +2263 -> 2269 conditional = ((???*0* | ":" | {}) !== {}) - *0* s3 ⚠️ pattern without value -2265 -> 2266 call = (...) => s0() +2269 -> 2270 call = (...) => s0() -2265 -> 2267 conditional = ((???*0* | []) !== {}) +2269 -> 2271 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -2267 -> 2268 call = (...) => s0() +2271 -> 2272 call = (...) => s0() -2267 -> 2269 conditional = (???*0* !== {}) +2271 -> 2273 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2269 -> 2270 call = (...) => {"key": key, "value": value}(???*0*, ???*1*) +2273 -> 2274 call = (...) => {"key": key, "value": value}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2271 unreachable = ???*0* +0 -> 2275 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2272 call = (...) => s0() +0 -> 2276 call = (...) => s0() -0 -> 2273 conditional = (???*0* !== {}) +0 -> 2277 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2273 -> 2274 call = (...) => {"type": "collection_expression", "expression": expression}(???*0*) +2277 -> 2278 call = (...) => {"type": "collection_expression", "expression": expression}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2275 unreachable = ???*0* +0 -> 2279 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2276 call = (...) => s0() +0 -> 2280 call = (...) => s0() -0 -> 2277 conditional = (???*0* !== {}) +0 -> 2281 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2277 -> 2278 call = (...) => s0() +2281 -> 2282 call = (...) => s0() -2277 -> 2279 conditional = (???*0* !== {}) +2281 -> 2283 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2279 -> 2281 member call = ???*0*["charCodeAt"](???*1*) +2283 -> 2285 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2279 -> 2282 conditional = (???*0* === 46) +2283 -> 2286 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2282 -> 2283 conditional = ((0 | ???*0*) === 0) +2286 -> 2287 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2283 -> 2284 call = (...) => undefined( +2287 -> 2288 call = (...) => undefined( {"type": "literal", "text": ".", "ignoreCase": false} ) -2279 -> 2285 conditional = ((???*0* | "." | {} | "[") !== {}) +2283 -> 2289 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -2285 -> 2286 call = (...) => s0() +2289 -> 2290 call = (...) => s0() -2285 -> 2287 conditional = ((???*0* | []) !== {}) +2289 -> 2291 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2287 -> 2288 call = (...) => s0() +2291 -> 2292 call = (...) => s0() -2287 -> 2289 conditional = (???*0* !== {}) +2291 -> 2293 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2289 -> 2290 call = (...) => s0() +2293 -> 2294 call = (...) => s0() -2289 -> 2291 conditional = ((???*0* | []) !== {}) +2293 -> 2295 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -2291 -> 2292 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) +2295 -> 2296 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2277 -> 2293 conditional = (???*0* === {}) +2281 -> 2297 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2293 -> 2294 call = (...) => s0() +2297 -> 2298 call = (...) => s0() -2293 -> 2295 conditional = (???*0* !== {}) +2297 -> 2299 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2295 -> 2297 member call = ???*0*["charCodeAt"](???*1*) +2299 -> 2301 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2295 -> 2298 conditional = (???*0* === 91) +2299 -> 2302 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2298 -> 2299 conditional = ((0 | ???*0*) === 0) +2302 -> 2303 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2299 -> 2300 call = (...) => undefined( +2303 -> 2304 call = (...) => undefined( {"type": "literal", "text": "[", "ignoreCase": false} ) -2295 -> 2301 conditional = ((???*0* | "." | {} | "[") !== {}) +2299 -> 2305 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -2301 -> 2302 call = (...) => s0() +2305 -> 2306 call = (...) => s0() -2301 -> 2303 conditional = ((???*0* | []) !== {}) +2305 -> 2307 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2303 -> 2304 call = (...) => s0() +2307 -> 2308 call = (...) => s0() -2303 -> 2305 conditional = (???*0* === {}) +2307 -> 2309 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2305 -> 2306 call = (...) => s0() +2309 -> 2310 call = (...) => s0() -2305 -> 2307 conditional = (???*0* === {}) +2309 -> 2311 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2307 -> 2308 call = (...) => s0() +2311 -> 2312 call = (...) => s0() -2303 -> 2309 conditional = (???*0* !== {}) +2307 -> 2313 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2309 -> 2310 call = (...) => s0() +2313 -> 2314 call = (...) => s0() -2309 -> 2311 conditional = ((???*0* | []) !== {}) +2313 -> 2315 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -2311 -> 2313 member call = ???*0*["charCodeAt"](???*1*) +2315 -> 2317 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2311 -> 2314 conditional = (???*0* === 93) +2315 -> 2318 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2314 -> 2315 conditional = ((0 | ???*0*) === 0) +2318 -> 2319 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2315 -> 2316 call = (...) => undefined( +2319 -> 2320 call = (...) => undefined( {"type": "literal", "text": "]", "ignoreCase": false} ) -2311 -> 2317 conditional = ((???*0* | "]" | {}) !== {}) +2315 -> 2321 conditional = ((???*0* | "]" | {}) !== {}) - *0* s9 ⚠️ pattern without value -2317 -> 2318 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) +2321 -> 2322 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2277 -> 2319 conditional = (???*0* !== {}) +2281 -> 2323 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2319 -> 2321 member call = (???*0* | [] | {})["push"](???*1*) +2323 -> 2325 member call = (???*0* | [] | {})["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -2319 -> 2322 call = (...) => s0() +2323 -> 2326 call = (...) => s0() -2319 -> 2323 conditional = (???*0* !== {}) +2323 -> 2327 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2323 -> 2325 member call = ???*0*["charCodeAt"](???*1*) +2327 -> 2329 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2323 -> 2326 conditional = (???*0* === 46) +2327 -> 2330 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2326 -> 2327 conditional = ((0 | ???*0*) === 0) +2330 -> 2331 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2327 -> 2328 call = (...) => undefined( +2331 -> 2332 call = (...) => undefined( {"type": "literal", "text": ".", "ignoreCase": false} ) -2323 -> 2329 conditional = ((???*0* | "." | {} | "[") !== {}) +2327 -> 2333 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -2329 -> 2330 call = (...) => s0() +2333 -> 2334 call = (...) => s0() -2329 -> 2331 conditional = ((???*0* | []) !== {}) +2333 -> 2335 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2331 -> 2332 call = (...) => s0() +2335 -> 2336 call = (...) => s0() -2331 -> 2333 conditional = (???*0* !== {}) +2335 -> 2337 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2333 -> 2334 call = (...) => s0() +2337 -> 2338 call = (...) => s0() -2333 -> 2335 conditional = ((???*0* | []) !== {}) +2337 -> 2339 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -2335 -> 2336 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) +2339 -> 2340 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2319 -> 2337 conditional = (???*0* === {}) +2323 -> 2341 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2337 -> 2338 call = (...) => s0() +2341 -> 2342 call = (...) => s0() -2337 -> 2339 conditional = (???*0* !== {}) +2341 -> 2343 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2339 -> 2341 member call = ???*0*["charCodeAt"](???*1*) +2343 -> 2345 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2339 -> 2342 conditional = (???*0* === 91) +2343 -> 2346 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2342 -> 2343 conditional = ((0 | ???*0*) === 0) +2346 -> 2347 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2343 -> 2344 call = (...) => undefined( +2347 -> 2348 call = (...) => undefined( {"type": "literal", "text": "[", "ignoreCase": false} ) -2339 -> 2345 conditional = ((???*0* | "." | {} | "[") !== {}) +2343 -> 2349 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -2345 -> 2346 call = (...) => s0() +2349 -> 2350 call = (...) => s0() -2345 -> 2347 conditional = ((???*0* | []) !== {}) +2349 -> 2351 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2347 -> 2348 call = (...) => s0() +2351 -> 2352 call = (...) => s0() -2347 -> 2349 conditional = (???*0* === {}) +2351 -> 2353 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2349 -> 2350 call = (...) => s0() +2353 -> 2354 call = (...) => s0() -2349 -> 2351 conditional = (???*0* === {}) +2353 -> 2355 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2351 -> 2352 call = (...) => s0() +2355 -> 2356 call = (...) => s0() -2347 -> 2353 conditional = (???*0* !== {}) +2351 -> 2357 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2353 -> 2354 call = (...) => s0() +2357 -> 2358 call = (...) => s0() -2353 -> 2355 conditional = ((???*0* | []) !== {}) +2357 -> 2359 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -2355 -> 2357 member call = ???*0*["charCodeAt"](???*1*) +2359 -> 2361 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2355 -> 2358 conditional = (???*0* === 93) +2359 -> 2362 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2358 -> 2359 conditional = ((0 | ???*0*) === 0) +2362 -> 2363 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2359 -> 2360 call = (...) => undefined( +2363 -> 2364 call = (...) => undefined( {"type": "literal", "text": "]", "ignoreCase": false} ) -2355 -> 2361 conditional = ((???*0* | "]" | {}) !== {}) +2359 -> 2365 conditional = ((???*0* | "]" | {}) !== {}) - *0* s9 ⚠️ pattern without value -2361 -> 2362 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) +2365 -> 2366 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2277 -> 2363 conditional = ((???*0* | [] | {}) !== {}) +2281 -> 2367 conditional = ((???*0* | [] | {}) !== {}) - *0* s2 ⚠️ pattern without value -2363 -> 2364 call = (...) => tail["reduce"](*arrow function 16259*, head)(???*0*, (???*1* | [] | {})) +2367 -> 2368 call = (...) => tail["reduce"](*arrow function 16259*, head)(???*0*, (???*1* | [] | {})) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 2365 unreachable = ???*0* +0 -> 2369 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2366 call = (...) => s0() +0 -> 2370 call = (...) => s0() -0 -> 2367 conditional = (???*0* !== {}) +0 -> 2371 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2367 -> 2368 call = (...) => {"type": "collection_subquery_expression", "expression": expression}(???*0*) +2371 -> 2372 call = (...) => {"type": "collection_subquery_expression", "expression": expression}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2369 unreachable = ???*0* +0 -> 2373 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2370 call = (...) => s0() +0 -> 2374 call = (...) => s0() -0 -> 2371 conditional = (???*0* === {}) +0 -> 2375 conditional = (???*0* === {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2371 -> 2372 call = (...) => s0() +2375 -> 2376 call = (...) => s0() -0 -> 2373 conditional = (???*0* !== {}) +0 -> 2377 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2373 -> 2374 call = (...) => {"type": "top_specification", "value": value}(???*0*) +2377 -> 2378 call = (...) => {"type": "top_specification", "value": value}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2375 unreachable = ???*0* +0 -> 2379 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2378 member call = ???*0*["charAt"](???*1*) +0 -> 2382 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2379 member call = /^[0-9]/["test"](???*0*) +0 -> 2383 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 2380 conditional = /^[0-9]/["test"](???*0*) +0 -> 2384 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2380 -> 2382 member call = ???*0*["charAt"](???*1*) +2384 -> 2386 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2380 -> 2383 conditional = ((0 | ???*0*) === 0) +2384 -> 2387 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2383 -> 2384 call = (...) => undefined( +2387 -> 2388 call = (...) => undefined( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -0 -> 2385 conditional = ((???*0* | ???*1* | {}) !== {}) +0 -> 2389 conditional = ((???*0* | ???*1* | {}) !== {}) - *0* s2 ⚠️ pattern without value - *1* ???*2*["charAt"](peg$currPos) @@ -8735,7 +8735,7 @@ - *2* arguments[0] ⚠️ function calls are not analyzed yet -2385 -> 2387 member call = (???*0* | [] | {} | {"type": "number_constant", "value": ???*1*})["push"]((???*3* | ???*4* | {})) +2389 -> 2391 member call = (???*0* | [] | {} | {"type": "number_constant", "value": ???*1*})["push"]((???*3* | ???*4* | {})) - *0* s1 ⚠️ pattern without value - *1* ???*2*(text()) @@ -8751,39 +8751,39 @@ - *5* arguments[0] ⚠️ function calls are not analyzed yet -2385 -> 2390 member call = ???*0*["charAt"](???*1*) +2389 -> 2394 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2385 -> 2391 member call = /^[0-9]/["test"](???*0*) +2389 -> 2395 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2385 -> 2392 conditional = /^[0-9]/["test"](???*0*) +2389 -> 2396 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2392 -> 2394 member call = ???*0*["charAt"](???*1*) +2396 -> 2398 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2392 -> 2395 conditional = ((0 | ???*0*) === 0) +2396 -> 2399 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2395 -> 2396 call = (...) => undefined( +2399 -> 2400 call = (...) => undefined( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -0 -> 2397 conditional = ((???*0* | [] | {} | {"type": "number_constant", "value": ???*1*}) !== {}) +0 -> 2401 conditional = ((???*0* | [] | {} | {"type": "number_constant", "value": ???*1*}) !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*(text()) @@ -8793,125 +8793,125 @@ ⚠️ unknown global ⚠️ This value might have side effects -2397 -> 2398 call = (...) => {"type": "number_constant", "value": FreeVar(Number)(text())}() +2401 -> 2402 call = (...) => {"type": "number_constant", "value": FreeVar(Number)(text())}() -0 -> 2399 unreachable = ???*0* +0 -> 2403 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2400 call = (...) => s0() +0 -> 2404 call = (...) => s0() -0 -> 2401 conditional = (???*0* !== {}) +0 -> 2405 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2401 -> 2402 call = (...) => s0() +2405 -> 2406 call = (...) => s0() -2401 -> 2403 conditional = (???*0* !== {}) +2405 -> 2407 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2403 -> 2405 member call = ???*0*["charCodeAt"](???*1*) +2407 -> 2409 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2403 -> 2406 conditional = (???*0* === 44) +2407 -> 2410 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2406 -> 2407 conditional = ((0 | ???*0*) === 0) +2410 -> 2411 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2407 -> 2408 call = (...) => undefined( +2411 -> 2412 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -2403 -> 2409 conditional = ((???*0* | "," | {}) !== {}) +2407 -> 2413 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -2409 -> 2410 call = (...) => s0() +2413 -> 2414 call = (...) => s0() -2409 -> 2411 conditional = ((???*0* | []) !== {}) +2413 -> 2415 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2411 -> 2412 call = (...) => s0() +2415 -> 2416 call = (...) => s0() -2411 -> 2413 conditional = (???*0* !== {}) +2415 -> 2417 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2413 -> 2414 call = (...) => v(???*0*, ???*1*) +2417 -> 2418 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2401 -> 2416 member call = (???*0* | [])["push"](???*1*) +2405 -> 2420 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -2401 -> 2417 call = (...) => s0() +2405 -> 2421 call = (...) => s0() -2401 -> 2418 conditional = (???*0* !== {}) +2405 -> 2422 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2418 -> 2420 member call = ???*0*["charCodeAt"](???*1*) +2422 -> 2424 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2418 -> 2421 conditional = (???*0* === 44) +2422 -> 2425 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2421 -> 2422 conditional = ((0 | ???*0*) === 0) +2425 -> 2426 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2422 -> 2423 call = (...) => undefined( +2426 -> 2427 call = (...) => undefined( {"type": "literal", "text": ",", "ignoreCase": false} ) -2418 -> 2424 conditional = ((???*0* | "," | {}) !== {}) +2422 -> 2428 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -2424 -> 2425 call = (...) => s0() +2428 -> 2429 call = (...) => s0() -2424 -> 2426 conditional = ((???*0* | []) !== {}) +2428 -> 2430 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2426 -> 2427 call = (...) => s0() +2430 -> 2431 call = (...) => s0() -2426 -> 2428 conditional = (???*0* !== {}) +2430 -> 2432 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2428 -> 2429 call = (...) => v(???*0*, ???*1*) +2432 -> 2433 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2401 -> 2430 conditional = ((???*0* | []) !== {}) +2405 -> 2434 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2430 -> 2431 call = (...) => (head ? ???*0* : [])(???*1*, (???*2* | [])) +2434 -> 2435 call = (...) => (head ? ???*0* : [])(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -8919,85 +8919,85 @@ - *2* s2 ⚠️ pattern without value -0 -> 2432 unreachable = ???*0* +0 -> 2436 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2434 member call = ???*0*["charCodeAt"](???*1*) +0 -> 2438 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2435 conditional = (???*0* === 40) +0 -> 2439 conditional = (???*0* === 40) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2435 -> 2436 conditional = ((0 | ???*0*) === 0) +2439 -> 2440 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2436 -> 2437 call = (...) => undefined( +2440 -> 2441 call = (...) => undefined( {"type": "literal", "text": "(", "ignoreCase": false} ) -0 -> 2438 conditional = (???*0* !== {}) +0 -> 2442 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2438 -> 2439 call = (...) => s0() +2442 -> 2443 call = (...) => s0() -2438 -> 2440 conditional = ((???*0* | []) !== {}) +2442 -> 2444 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2440 -> 2441 call = (...) => s0() +2444 -> 2445 call = (...) => s0() -2440 -> 2442 conditional = (???*0* !== {}) +2444 -> 2446 conditional = (???*0* !== {}) - *0* max number of linking steps reached ⚠️ This value might have side effects -2442 -> 2443 call = (...) => s0() +2446 -> 2447 call = (...) => s0() -2442 -> 2444 conditional = ((???*0* | []) !== {}) +2446 -> 2448 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -2444 -> 2446 member call = ???*0*["charCodeAt"](???*1*) +2448 -> 2450 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analyzed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2444 -> 2447 conditional = (???*0* === 41) +2448 -> 2451 conditional = (???*0* === 41) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analyzed yet -2447 -> 2448 conditional = ((0 | ???*0*) === 0) +2451 -> 2452 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2448 -> 2449 call = (...) => undefined( +2452 -> 2453 call = (...) => undefined( {"type": "literal", "text": ")", "ignoreCase": false} ) -2444 -> 2450 conditional = ((???*0* | ")" | {}) !== {}) +2448 -> 2454 conditional = ((???*0* | ")" | {}) !== {}) - *0* s5 ⚠️ pattern without value -2450 -> 2451 call = (...) => subquery(???*0*) +2454 -> 2455 call = (...) => subquery(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2452 unreachable = ???*0* +0 -> 2456 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects -0 -> 2454 member call = ???*0*["reduce"]( +0 -> 2458 member call = ???*0*["reduce"]( (...) => {"type": "scalar_binary_expression", "left": left, "operator": operator, "right": right}, ???*1* ) @@ -9006,6 +9006,6 @@ - *1* arguments[0] ⚠️ function calls are not analyzed yet -0 -> 2455 unreachable = ???*0* +0 -> 2459 unreachable = ???*0* - *0* unreachable ⚠️ This value might have side effects diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/process-and-os/graph-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/process-and-os/graph-effects.snapshot index b42c0994a071..559e0de6e047 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/process-and-os/graph-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/process-and-os/graph-effects.snapshot @@ -1,4 +1,79 @@ [ + DestructuredMember { + obj: Call( + 3, + FreeVar( + "require", + ), + [ + Constant( + Str( + Atom( + "os", + ), + ), + ), + ], + ), + prop: Constant( + Str( + Atom( + "platform", + ), + ), + ), + span: 9..17, + }, + DestructuredMember { + obj: Call( + 3, + FreeVar( + "require", + ), + [ + Constant( + Str( + Atom( + "os", + ), + ), + ), + ], + ), + prop: Constant( + Str( + Atom( + "endianness", + ), + ), + ), + span: 19..29, + }, + DestructuredMember { + obj: Call( + 3, + FreeVar( + "require", + ), + [ + Constant( + Str( + Atom( + "os", + ), + ), + ), + ], + ), + prop: Constant( + Str( + Atom( + "arch", + ), + ), + ), + span: 31..35, + }, FreeVar { var: "require", ast_path: [ @@ -85,6 +160,31 @@ in_try: false, new: false, }, + DestructuredMember { + obj: Call( + 3, + FreeVar( + "require", + ), + [ + Constant( + Str( + Atom( + "process", + ), + ), + ), + ], + ), + prop: Constant( + Str( + Atom( + "platform", + ), + ), + ), + span: 63..71, + }, FreeVar { var: "require", ast_path: [ diff --git a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/process-and-os/resolved-effects.snapshot b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/process-and-os/resolved-effects.snapshot index 437f7e9e19b1..4cd95a4caf4a 100644 --- a/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/process-and-os/resolved-effects.snapshot +++ b/turbopack/crates/turbopack-ecmascript/tests/analyzer/graph/process-and-os/resolved-effects.snapshot @@ -1,79 +1,79 @@ -0 -> 1 free var = FreeVar(require) +0 -> 4 free var = FreeVar(require) -0 -> 2 call = require*0*("os") +0 -> 5 call = require*0*("os") - *0* require: The require method from CommonJS -0 -> 3 free var = FreeVar(require) +0 -> 7 free var = FreeVar(require) -0 -> 4 call = require*0*("process") +0 -> 8 call = require*0*("process") - *0* require: The require method from CommonJS -0 -> 5 free var = FreeVar(process) +0 -> 9 free var = FreeVar(process) -0 -> 6 free var = FreeVar(require) +0 -> 10 free var = FreeVar(require) -0 -> 8 free var = FreeVar(process) +0 -> 12 free var = FreeVar(process) -0 -> 9 call = os.process*0*() +0 -> 13 call = os.process*0*() - *0* os.process: The Node.js os.process method: https://nodejs.org/api/os.html#os_os_process -0 -> 10 call = os.endianness*0*() +0 -> 14 call = os.endianness*0*() - *0* os.endianness: The Node.js os.endianness method: https://nodejs.org/api/os.html#os_os_endianness -0 -> 11 call = require*0*("esbuild-x64-linux-LE") +0 -> 15 call = require*0*("esbuild-x64-linux-LE") - *0* require: The require method from CommonJS -0 -> 12 free var = FreeVar(require) +0 -> 16 free var = FreeVar(require) -0 -> 13 call = os.arch*0*() +0 -> 17 call = os.arch*0*() - *0* os.arch: The Node.js os.arch method: https://nodejs.org/api/os.html#os_os_arch -0 -> 14 call = os.process*0*() +0 -> 18 call = os.process*0*() - *0* os.process: The Node.js os.process method: https://nodejs.org/api/os.html#os_os_process -0 -> 15 call = os.endianness*0*() +0 -> 19 call = os.endianness*0*() - *0* os.endianness: The Node.js os.endianness method: https://nodejs.org/api/os.html#os_os_endianness -0 -> 16 call = require*0*("esbuild-x64-linux-LE") +0 -> 20 call = require*0*("esbuild-x64-linux-LE") - *0* require: The require method from CommonJS -0 -> 17 free var = FreeVar(require) +0 -> 21 free var = FreeVar(require) -0 -> 18 call = os.arch*0*() +0 -> 22 call = os.arch*0*() - *0* os.arch: The Node.js os.arch method: https://nodejs.org/api/os.html#os_os_arch -0 -> 20 free var = FreeVar(process) +0 -> 24 free var = FreeVar(process) -0 -> 21 call = os.endianness*0*() +0 -> 25 call = os.endianness*0*() - *0* os.endianness: The Node.js os.endianness method: https://nodejs.org/api/os.html#os_os_endianness -0 -> 22 call = require*0*("esbuild-x64-linux-LE") +0 -> 26 call = require*0*("esbuild-x64-linux-LE") - *0* require: The require method from CommonJS -0 -> 23 free var = FreeVar(require) +0 -> 27 free var = FreeVar(require) -0 -> 25 free var = FreeVar(process) +0 -> 29 free var = FreeVar(process) -0 -> 27 free var = FreeVar(process) +0 -> 31 free var = FreeVar(process) -0 -> 28 call = os.endianness*0*() +0 -> 32 call = os.endianness*0*() - *0* os.endianness: The Node.js os.endianness method: https://nodejs.org/api/os.html#os_os_endianness -0 -> 29 call = require*0*("esbuild-x64-linux-LE") +0 -> 33 call = require*0*("esbuild-x64-linux-LE") - *0* require: The require method from CommonJS -0 -> 30 free var = FreeVar(require) +0 -> 34 free var = FreeVar(require) -0 -> 33 call = os.endianness*0*() +0 -> 37 call = os.endianness*0*() - *0* os.endianness: The Node.js os.endianness method: https://nodejs.org/api/os.html#os_os_endianness -0 -> 34 call = require*0*("esbuild-x64-linux-LE") +0 -> 38 call = require*0*("esbuild-x64-linux-LE") - *0* require: The require method from CommonJS -0 -> 35 free var = FreeVar(require) +0 -> 39 free var = FreeVar(require) -0 -> 37 call = os.endianness*0*() +0 -> 41 call = os.endianness*0*() - *0* os.endianness: The Node.js os.endianness method: https://nodejs.org/api/os.html#os_os_endianness -0 -> 38 call = require*0*("esbuild-x64-linux-LE") +0 -> 42 call = require*0*("esbuild-x64-linux-LE") - *0* require: The require method from CommonJS diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/env-vars.codegen.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/env-vars.codegen.snapshot new file mode 100644 index 000000000000..b3405f2970f0 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/env-vars.codegen.snapshot @@ -0,0 +1,3 @@ +runtime: [ + "FOO1", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/env-vars.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/env-vars.snapshot new file mode 100644 index 000000000000..b3405f2970f0 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/env-vars.snapshot @@ -0,0 +1,3 @@ +runtime: [ + "FOO1", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/env-vars.tracing.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/env-vars.tracing.snapshot new file mode 100644 index 000000000000..b3405f2970f0 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/env-vars.tracing.snapshot @@ -0,0 +1,3 @@ +runtime: [ + "FOO1", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/input.js b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/input.js new file mode 100644 index 000000000000..fce401524abf --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/complex/input.js @@ -0,0 +1,9 @@ +// e2e test for a common pattern +if ( + typeof process === 'object' && + process && + process.env && + process.env.FOO1 !== 'development' +) { + console.log('hi') +} diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/env-vars.codegen.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/env-vars.codegen.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/env-vars.codegen.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/env-vars.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/env-vars.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/env-vars.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/env-vars.tracing.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/env-vars.tracing.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/env-vars.tracing.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/input.js b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/input.js new file mode 100644 index 000000000000..1482ae6621f9 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-export-process-env/input.js @@ -0,0 +1 @@ +export const x = process.env diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/env-vars.codegen.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/env-vars.codegen.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/env-vars.codegen.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/env-vars.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/env-vars.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/env-vars.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/env-vars.tracing.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/env-vars.tracing.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/env-vars.tracing.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/input.js b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/input.js new file mode 100644 index 000000000000..e9acc37d0f9f --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default-rest-spread/input.js @@ -0,0 +1,5 @@ +// TODO properly handle Pat::Assign +function readEnv({ FOO1, ...rest } = process.env) { + return rest +} +console.log(readEnv()) diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/env-vars.codegen.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/env-vars.codegen.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/env-vars.codegen.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/env-vars.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/env-vars.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/env-vars.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/env-vars.tracing.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/env-vars.tracing.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/env-vars.tracing.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/input.js b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/input.js new file mode 100644 index 000000000000..55a9975c065d --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-default/input.js @@ -0,0 +1,5 @@ +// TODO properly handle Pat::Assign +function readEnv(env = process.env) { + return env.FOO1 +} +console.log(readEnv()) diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/env-vars.codegen.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/env-vars.codegen.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/env-vars.codegen.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/env-vars.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/env-vars.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/env-vars.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/env-vars.tracing.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/env-vars.tracing.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/env-vars.tracing.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/input.js b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/input.js new file mode 100644 index 000000000000..6ea9a6636035 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-fn-process-env/input.js @@ -0,0 +1,3 @@ +function foo() {} + +foo(process.env) diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/env-vars.codegen.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/env-vars.codegen.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/env-vars.codegen.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/env-vars.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/env-vars.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/env-vars.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/env-vars.tracing.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/env-vars.tracing.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/env-vars.tracing.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/input.js b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/input.js new file mode 100644 index 000000000000..dfba3810b392 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-in/input.js @@ -0,0 +1 @@ +console.log(dynamic in process.env) diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/env-vars.codegen.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/env-vars.codegen.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/env-vars.codegen.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/env-vars.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/env-vars.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/env-vars.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/env-vars.tracing.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/env-vars.tracing.snapshot new file mode 100644 index 000000000000..e08877920854 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/env-vars.tracing.snapshot @@ -0,0 +1 @@ +runtime: [] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/input.js b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/input.js new file mode 100644 index 000000000000..2f2be8c37b07 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-member/input.js @@ -0,0 +1 @@ +console.log(process.env[dynamic]) diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/env-vars.codegen.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/env-vars.codegen.snapshot new file mode 100644 index 000000000000..b3405f2970f0 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/env-vars.codegen.snapshot @@ -0,0 +1,3 @@ +runtime: [ + "FOO1", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/env-vars.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/env-vars.snapshot new file mode 100644 index 000000000000..b3405f2970f0 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/env-vars.snapshot @@ -0,0 +1,3 @@ +runtime: [ + "FOO1", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/env-vars.tracing.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/env-vars.tracing.snapshot new file mode 100644 index 000000000000..b3405f2970f0 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/env-vars.tracing.snapshot @@ -0,0 +1,3 @@ +runtime: [ + "FOO1", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/input.js b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/input.js new file mode 100644 index 000000000000..4ad9d05d2fe1 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/dynamic-rest-spread/input.js @@ -0,0 +1 @@ +const { FOO1, ...rest } = process.env diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/env-vars.codegen.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/env-vars.codegen.snapshot new file mode 100644 index 000000000000..9b3527dc3e6c --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/env-vars.codegen.snapshot @@ -0,0 +1,3 @@ +runtime: [ + "DECOY", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/env-vars.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/env-vars.snapshot new file mode 100644 index 000000000000..9b3527dc3e6c --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/env-vars.snapshot @@ -0,0 +1,3 @@ +runtime: [ + "DECOY", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/env-vars.tracing.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/env-vars.tracing.snapshot new file mode 100644 index 000000000000..9b3527dc3e6c --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/env-vars.tracing.snapshot @@ -0,0 +1,3 @@ +runtime: [ + "DECOY", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/input.js b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/input.js new file mode 100644 index 000000000000..ff0c821119a6 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/fn-map/input.js @@ -0,0 +1,5 @@ +globalThis.blackbox = (v) => ({ DECOY: v.FOOBAR }) + +// TODO fix this +const v = blackbox(process.env).DECOY +console.log(v) diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/env-vars.codegen.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/env-vars.codegen.snapshot new file mode 100644 index 000000000000..943f898b486c --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/env-vars.codegen.snapshot @@ -0,0 +1,8 @@ +runtime: [ + "FOO1", + "FOO2", + "FOO3", + "FOO4", + "FOO5", + "FOO6", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/env-vars.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/env-vars.snapshot new file mode 100644 index 000000000000..943f898b486c --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/env-vars.snapshot @@ -0,0 +1,8 @@ +runtime: [ + "FOO1", + "FOO2", + "FOO3", + "FOO4", + "FOO5", + "FOO6", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/env-vars.tracing.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/env-vars.tracing.snapshot new file mode 100644 index 000000000000..943f898b486c --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/env-vars.tracing.snapshot @@ -0,0 +1,8 @@ +runtime: [ + "FOO1", + "FOO2", + "FOO3", + "FOO4", + "FOO5", + "FOO6", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/input.js b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/input.js new file mode 100644 index 000000000000..76766a357d82 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static-assign-obj/input.js @@ -0,0 +1,54 @@ +// Assigning process.env +const env = process.env +if (env.FOO1 === 'x') { + return false +} +if ('FOO2' in env) { + return true +} + +// --- + +// Assigning process +const p = process +if (p.env.FOO3 === 'x') { + return false +} +if ('FOO4' in p.env) { + return true +} + +// --- + +// Assigning process with indirection +const p1 = p +if (p1.env.FOO5 === 'x') { + return false +} +if ('FOO6' in p1.env) { + return true +} + +// --- + +// An alternative (process.env | unknown) +let e +if (foo) { + e = foo +} else { + e = process.env +} +// TODO currently not tracked +console.log(e.FOO7) + +// --- + +// An alternative (process|unknown).env +let p2 +if (foo) { + p2 = foo +} else { + p2 = process +} +// TODO currently not tracked +console.log(p2.env.FOO8) diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/env-vars.codegen.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/env-vars.codegen.snapshot new file mode 100644 index 000000000000..2f7e0db383f7 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/env-vars.codegen.snapshot @@ -0,0 +1,8 @@ +runtime: [ + "FOO1", + "FOO2", + "FOO3", + "FOO4", + "FOO5", + "INLINED3", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/env-vars.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/env-vars.snapshot new file mode 100644 index 000000000000..2f7e0db383f7 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/env-vars.snapshot @@ -0,0 +1,8 @@ +runtime: [ + "FOO1", + "FOO2", + "FOO3", + "FOO4", + "FOO5", + "INLINED3", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/env-vars.tracing.snapshot b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/env-vars.tracing.snapshot new file mode 100644 index 000000000000..2f7e0db383f7 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/env-vars.tracing.snapshot @@ -0,0 +1,8 @@ +runtime: [ + "FOO1", + "FOO2", + "FOO3", + "FOO4", + "FOO5", + "INLINED3", +] diff --git a/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/input.js b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/input.js new file mode 100644 index 000000000000..849d68f02033 --- /dev/null +++ b/turbopack/crates/turbopack-ecmascript/tests/references/env-var-info/static/input.js @@ -0,0 +1,36 @@ +if (process.env.FOO1 === 'x') { + return false +} +if (process.env.INLINED1 === 'x') { + return false +} + +if ('FOO2' in process.env) { + return true +} +if ('INLINED2' in process.env) { + return true +} + +const NAME = 'FOO3' +console.log(process.env[NAME]) + +const { FOO4, ['FOO5']: renamed, INLINED3 } = process.env +console.log(FOO4, renamed) +// TODO this is actually not inlined yet +console.log(INLINED3) + +// TODO not tracked yet +// The re-entered object pattern now receives: +// Alternatives [ +// Argument(...), +// process.env +// ] +// add_object_pat_effects() therefore creates DestructuredMember with that Alternatives object. +// Later, Effect::DestructuredMember calls get_definable_name(). That function does not handle JsValue::Alternatives, so it returns None instead of recognizing the process.env alternative. +// Thus FOO6 and INLINED4 remain untracked in `function readEnv({ FOO6, INLINED4 } = process.env)`. +function readEnv({ FOO6, INLINED4 } = process.env) { + // TODO this is actually not inlined yet + return FOO6 + INLINED4 +} +console.log(readEnv()) diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/input/index.js b/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/input/index.js index c3d49afe1ebb..0c4c0c8881ea 100644 --- a/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/input/index.js +++ b/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/input/index.js @@ -72,3 +72,10 @@ if (!('NODE_ENV' in process.env)) { console.log('existing') } console.log('NODE_ENV' in process.env) + +const { NODE_ENV: foo } = p.env +if (foo === 'production') { + console.log('existing') +} +// TODO ideally this would also be inlined +console.log(foo) diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/output/1do3_crates_turbopack-tests_tests_snapshot_comptime_define_input_index_1etshin.js b/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/output/1do3_crates_turbopack-tests_tests_snapshot_comptime_define_input_index_1etshin.js index 2fc4c90ba4c4..654ffb457ba9 100644 --- a/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/output/1do3_crates_turbopack-tests_tests_snapshot_comptime_define_input_index_1etshin.js +++ b/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/output/1do3_crates_turbopack-tests_tests_snapshot_comptime_define_input_index_1etshin.js @@ -66,6 +66,11 @@ if (("TURBOPACK compile-time value", "replacement") === 'replacement') { if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable ; console.log(("TURBOPACK compile-time value", true)); +const { NODE_ENV: foo } = p.env; +if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable +; +// TODO ideally this would also be inlined +console.log(foo); }), ]); diff --git a/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/output/1do3_crates_turbopack-tests_tests_snapshot_comptime_define_input_index_1etshin.js.map b/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/output/1do3_crates_turbopack-tests_tests_snapshot_comptime_define_input_index_1etshin.js.map index 36d55fe7d427..177a4fd54962 100644 --- a/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/output/1do3_crates_turbopack-tests_tests_snapshot_comptime_define_input_index_1etshin.js.map +++ b/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/output/1do3_crates_turbopack-tests_tests_snapshot_comptime_define_input_index_1etshin.js.map @@ -2,5 +2,5 @@ "version": 3, "sources": [], "sections": [ - {"offset": {"line": 3, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/input/index.js"],"sourcesContent":["if (DEFINED_VALUE) {\n console.log('DEFINED_VALUE')\n}\n\nif (DEFINED_TRUE) {\n console.log('DEFINED_VALUE')\n}\n\nif (!DEFINED_NULL) {\n console.log('DEFINED_NULL', DEFINED_NULL)\n}\n\nif (DEFINED_INT) {\n console.log('DEFINED_INT', DEFINED_INT)\n}\n\nif (DEFINED_FLOAT) {\n console.log('DEFINED_FLOAT', DEFINED_FLOAT)\n}\n\nif (DEFINED_ARRAY) {\n console.log('DEFINED_ARRAY', DEFINED_ARRAY)\n}\n\nif (DEFINED_EVALUATE) {\n console.log('DEFINED_EVALUATE', DEFINED_EVALUATE)\n}\n\nif (DEFINED_EVALUATE_NESTED) {\n console.log('DEFINED_EVALUATE_NESTED', DEFINED_EVALUATE_NESTED)\n}\n\nif (A.VERY.LONG.DEFINED.VALUE) {\n console.log('A.VERY.LONG.DEFINED.VALUE')\n}\n\nif (process.env.NODE_ENV) {\n console.log('something')\n}\n\nif (process.env.NODE_ENV === 'production') {\n console.log('production')\n}\n\nvar p = process\n\nconsole.log(A.VERY.LONG.DEFINED.VALUE)\nconsole.log(DEFINED_VALUE)\nconsole.log(p.env.NODE_ENV)\n\nif (p.env.NODE_ENV === 'production') {\n console.log('production')\n}\n\np.env.NODE_ENV == 'production'\n ? console.log('production')\n : console.log('development')\n\n// TODO short-circuit is not implemented yet\np.env.NODE_ENV != 'production' && console.log('development')\np.env.NODE_ENV == 'production' && console.log('production')\n\nconsole.log(__dirname)\n\n// Test that WARNED_VALUE triggers a warning but still gets replaced\nconsole.log(WARNED_VALUE)\nif (WARNED_VALUE === 'replacement') {\n console.log('warning replacement works')\n}\n\nif (!('NODE_ENV' in process.env)) {\n console.log('existing')\n}\nconsole.log('NODE_ENV' in process.env)\n"],"names":["console","log","p","process"],"mappings":"AAAA,wCAAmB;IACjBA,QAAQC,GAAG,CAAC;AACd;AAEA,wCAAkB;IAChBD,QAAQC,GAAG,CAAC;AACd;AAEA,wCAAmB;IACjBD,QAAQC,GAAG,CAAC;AACd;AAEA,wCAAiB;IACfD,QAAQC,GAAG,CAAC;AACd;AAEA,wCAAmB;IACjBD,QAAQC,GAAG,CAAC;AACd;AAEA,wCAAmB;IACjBD,QAAQC,GAAG,CAAC;;;;;;;;;AACd;AAEA,wCAAsB;IACpBD,QAAQC,GAAG,CAAC,qDAzBd,IAAI;AA0BJ;AAEA,wCAA6B;IAC3BD,QAAQC,GAAG,CAAC;;;yCA7Bd,IAAM;;AA8BN;AAEA,wCAA+B;IAC7BD,QAAQC,GAAG,CAAC;AACd;AAEA,wCAA0B;IACxBD,QAAQC,GAAG,CAAC;AACd;AAEA;;AAIA,IAAIC,IAAIC;AAERH,QAAQC,GAAG;;;AACXD,QAAQC,GAAG;AACXD,QAAQC,GAAG;AAEX;;AAIA,sCACI,0BACAD,QAAQC,GAAG,CAAC;AAEhB,4CAA4C;AAC5C,mDAAkB,gBAAgBD,QAAQC,GAAG,CAAC;AAC9C,mDAAkB,gBAAgBD,QAAQC,GAAG,CAAC;AAE9CD,QAAQC,GAAG;AAEX,oEAAoE;AACpED,QAAQC,GAAG;AACX,IAAI,oDAAiB,eAAe;IAClCD,QAAQC,GAAG,CAAC;AACd;AAEA;;AAGAD,QAAQC,GAAG"}}] + {"offset": {"line": 3, "column": 0}, "map": {"version":3,"sources":["turbopack:///[project]/turbopack/crates/turbopack-tests/tests/snapshot/comptime/define/input/index.js"],"sourcesContent":["if (DEFINED_VALUE) {\n console.log('DEFINED_VALUE')\n}\n\nif (DEFINED_TRUE) {\n console.log('DEFINED_VALUE')\n}\n\nif (!DEFINED_NULL) {\n console.log('DEFINED_NULL', DEFINED_NULL)\n}\n\nif (DEFINED_INT) {\n console.log('DEFINED_INT', DEFINED_INT)\n}\n\nif (DEFINED_FLOAT) {\n console.log('DEFINED_FLOAT', DEFINED_FLOAT)\n}\n\nif (DEFINED_ARRAY) {\n console.log('DEFINED_ARRAY', DEFINED_ARRAY)\n}\n\nif (DEFINED_EVALUATE) {\n console.log('DEFINED_EVALUATE', DEFINED_EVALUATE)\n}\n\nif (DEFINED_EVALUATE_NESTED) {\n console.log('DEFINED_EVALUATE_NESTED', DEFINED_EVALUATE_NESTED)\n}\n\nif (A.VERY.LONG.DEFINED.VALUE) {\n console.log('A.VERY.LONG.DEFINED.VALUE')\n}\n\nif (process.env.NODE_ENV) {\n console.log('something')\n}\n\nif (process.env.NODE_ENV === 'production') {\n console.log('production')\n}\n\nvar p = process\n\nconsole.log(A.VERY.LONG.DEFINED.VALUE)\nconsole.log(DEFINED_VALUE)\nconsole.log(p.env.NODE_ENV)\n\nif (p.env.NODE_ENV === 'production') {\n console.log('production')\n}\n\np.env.NODE_ENV == 'production'\n ? console.log('production')\n : console.log('development')\n\n// TODO short-circuit is not implemented yet\np.env.NODE_ENV != 'production' && console.log('development')\np.env.NODE_ENV == 'production' && console.log('production')\n\nconsole.log(__dirname)\n\n// Test that WARNED_VALUE triggers a warning but still gets replaced\nconsole.log(WARNED_VALUE)\nif (WARNED_VALUE === 'replacement') {\n console.log('warning replacement works')\n}\n\nif (!('NODE_ENV' in process.env)) {\n console.log('existing')\n}\nconsole.log('NODE_ENV' in process.env)\n\nconst { NODE_ENV: foo } = p.env\nif (foo === 'production') {\n console.log('existing')\n}\n// TODO ideally this would also be inlined\nconsole.log(foo)\n"],"names":["console","log","p","process","NODE_ENV","foo","env"],"mappings":"AAAA,wCAAmB;IACjBA,QAAQC,GAAG,CAAC;AACd;AAEA,wCAAkB;IAChBD,QAAQC,GAAG,CAAC;AACd;AAEA,wCAAmB;IACjBD,QAAQC,GAAG,CAAC;AACd;AAEA,wCAAiB;IACfD,QAAQC,GAAG,CAAC;AACd;AAEA,wCAAmB;IACjBD,QAAQC,GAAG,CAAC;AACd;AAEA,wCAAmB;IACjBD,QAAQC,GAAG,CAAC;;;;;;;;;AACd;AAEA,wCAAsB;IACpBD,QAAQC,GAAG,CAAC,qDAzBd,IAAI;AA0BJ;AAEA,wCAA6B;IAC3BD,QAAQC,GAAG,CAAC;;;yCA7Bd,IAAM;;AA8BN;AAEA,wCAA+B;IAC7BD,QAAQC,GAAG,CAAC;AACd;AAEA,wCAA0B;IACxBD,QAAQC,GAAG,CAAC;AACd;AAEA;;AAIA,IAAIC,IAAIC;AAERH,QAAQC,GAAG;;;AACXD,QAAQC,GAAG;AACXD,QAAQC,GAAG;AAEX;;AAIA,sCACI,0BACAD,QAAQC,GAAG,CAAC;AAEhB,4CAA4C;AAC5C,mDAAkB,gBAAgBD,QAAQC,GAAG,CAAC;AAC9C,mDAAkB,gBAAgBD,QAAQC,GAAG,CAAC;AAE9CD,QAAQC,GAAG;AAEX,oEAAoE;AACpED,QAAQC,GAAG;AACX,IAAI,oDAAiB,eAAe;IAClCD,QAAQC,GAAG,CAAC;AACd;AAEA;;AAGAD,QAAQC,GAAG;AAEX,MAAM,EAAEG,UAAUC,GAAG,EAAE,GAAGH,EAAEI,GAAG;AAC/B;;AAGA,0CAA0C;AAC1CN,QAAQC,GAAG,CAACI"}}] } \ No newline at end of file