@rust-js/resources 0.0.1

package/builtins/Cargo.toml

@@ -0,0 +1,20 @@
+# The js crate as a Cargo dependency (ADR 0101): rustc checks it, as
+# builtins/build.sh does, and rust-js reads its metadata (ADR 0102).
+[package]
+name = "rust-js-builtins"
+version = "0.0.1"
+edition = "2024"
+description = "JS's language, as rust-js compiles Rust to it: promises, errors, regular expressions, JSON"
+license = "MIT"
+repository = "https://github.com/rust-js-lang/rust-js"
+readme = "README.md"
+# Its Rust, not the repository's tools that build or generate it.
+include = ["src", "README.md"]
+
+[lib]
+name = "js"
+path = "src/lib.rs"
+
+# rust-js compiles with `--cfg=rust_js` (ADR 0113): a `cfg` Cargo checks for.
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ["cfg(rust_js)"] }

package/builtins/build.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# Compile the js crate's metadata, which is all programs need (ADR 0102),
+# for the target rust-js checks programs for (ADR 0090):
+#
+#   builtins/build.sh -o target/libjs.rmeta
+#
+# Then compile a program with `rust-js app.rs -- --extern js=<that file>`.
+set -euo pipefail
+cd "$(dirname "$0")"
+target=(--target=wasm32-unknown-unknown)
+for arg in "$@"; do
+  case "$arg" in --target | --target=*) target=() ;; esac
+done
+# rust-js compiles it, as rustc with rust-js's tool, `rust_js`, known (ADR
+# 0112): $RUST_JS_COMPILER, or this repository's own build.
+compiler=${RUST_JS_COMPILER:-$PWD/../target/debug/rust-js}
+# A packaged one is a JS launcher, run by the JS runtime the build is.
+rust_js=("$compiler")
+case "$compiler" in *.js) rust_js=("${RUST_JS_JS_RUNTIME:-node}" "$compiler") ;; esac
+exec "${rust_js[@]}" --rustc --edition=2024 --crate-type=lib --crate-name=js --emit=metadata ${target[@]+"${target[@]}"} src/lib.rs "$@"

package/builtins/src/lib.rs

@@ -0,0 +1,264 @@
+//! The JS language for rust-js (ADR 0102): what JS has that Rust's `std`
+//! doesn't, as ReScript's standard library has it. Its promises, errors and
+//! regular expressions, its byte buffers, its JSON, and its global functions,
+//! its timers too, as ReScript's has them: every JS runtime has them. What the
+//! browser adds is the webapi crate's; what `std` has, rust-js maps itself.
+//!
+//! It holds declarations only, so it's never compiled to JS: a program calls
+//! what it declares, and the calls become plain JS.
+
+use core::marker::PhantomData;
+
+/// `import "./App.css";` in the module's JS, for what a module does when
+/// it's loaded, as a bundler's CSS does (ADRs 0039 and 0110): written where
+/// it's needed, `js::import!("./App.css");`, as stable Rust has no inner
+/// attribute of a tool. It's a `const _` rust-js reads, and writes nothing of.
+#[macro_export]
+macro_rules! import {
+    ($path:literal) => {
+        #[cfg_attr(rust_js, rust_js::import = $path)]
+        const _: () = ();
+    };
+}
+
+/// The crate's own functions, fields and props are camelCase in JS, as its
+/// variables are (ADRs 0046 and 0110): `js::camel_case!();` at the crate root.
+#[macro_export]
+macro_rules! camel_case {
+    () => {
+        #[cfg_attr(rust_js, rust_js::camel_case)]
+        const _: () = ();
+    };
+}
+
+/// Any JS object. Every type here and in webapi holds a `PhantomData` of
+/// it, which is how rust-js knows it's a JS object, and so may a program's
+/// own: `pub struct EditorView(PhantomData<JsObject>);` (ADR 0111). A program
+/// never has one by value, only a reference a binding gives: its field is
+/// private, so nothing makes one, and it's neither `Send` nor `Sync`.
+#[cfg_attr(rust_js, rust_js::js_object)]
+pub struct JsObject(PhantomData<*mut ()>);
+
+/// A JS [`Promise`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+/// of a `T`. `.await` on one is JS's `await`; a rejected one throws, like a
+/// panic. See ADR 0029.
+pub struct Promise<T>(PhantomData<JsObject>, PhantomData<T>);
+
+impl<T> core::future::Future for Promise<T> {
+    type Output = T;
+
+    fn poll(self: core::pin::Pin<&mut Self>, _: &mut core::task::Context<'_>) -> core::task::Poll<T> {
+        unreachable!("rust-js compiles `.await` to JS's `await`")
+    }
+}
+
+/// `promise`, settled either way: its `.await` is `Ok` of what it fulfils
+/// with, or `Err` of what it's rejected with, where the `.await` of the
+/// promise itself would throw. For a promise of the webapi crate's, as
+/// `settle(window::fetch(window, url)).await` is a network error's `Err`
+/// (ADR 0035).
+#[cfg_attr(rust_js, rust_js::link_name = "this")]
+#[allow(unused_variables)]
+pub fn settle<T>(this: Promise<T>) -> Promise<Result<T, &'static JsError>> {
+    unreachable!()
+}
+
+unsafe extern "Rust" {
+    /// Run a future without waiting for it, as from an event handler:
+    /// `spawn(Box::new(async move { .. }))`. A JS promise is already
+    /// running, so in JS this is the promise itself, left unawaited.
+    #[link_name = "this"]
+    pub safe fn spawn(this: Box<dyn core::future::Future<Output = ()>>);
+
+    /// [`encodeURIComponent`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent):
+    /// `text` for a part of a URL, a query's value say.
+    #[link_name = "encodeURIComponent"]
+    pub safe fn encode_uri_component(text: &str) -> String;
+
+    /// [`encodeURI`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/encodeURI):
+    /// `text` for a whole URL, its `/`, `?` and `#` kept.
+    #[link_name = "encodeURI"]
+    pub safe fn encode_uri(text: &str) -> String;
+
+    /// [`decodeURIComponent`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent):
+    /// what `encode_uri_component` made, or the `URIError` of what it can't have.
+    #[link_name = "decodeURIComponent"]
+    pub safe fn decode_uri_component(text: &str) -> Result<String, &'static JsError>;
+
+    /// [`decodeURI`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/decodeURI):
+    /// what `encode_uri` made, or the `URIError` of what it can't have.
+    #[link_name = "decodeURI"]
+    pub safe fn decode_uri(text: &str) -> Result<String, &'static JsError>;
+}
+
+/// What `set_timeout` gives, to clear it with: a number in a browser, an
+/// object in Node.
+pub struct TimeoutId(PhantomData<JsObject>);
+
+/// What `set_interval` gives, to clear it with.
+pub struct IntervalId(PhantomData<JsObject>);
+
+// Timers: not the language's own, but every JS runtime's, browsers', workers'
+// and Node's, as ReScript's standard library has them (ADR 0102).
+unsafe extern "Rust" {
+    /// [`setTimeout(callback, ms)`](https://developer.mozilla.org/docs/Web/API/Window/setTimeout):
+    /// `callback` once, after at least `ms` milliseconds.
+    #[link_name = "setTimeout"]
+    pub safe fn set_timeout(callback: Box<dyn FnOnce()>, ms: u32) -> &'static TimeoutId;
+
+    /// [`clearTimeout(id)`](https://developer.mozilla.org/docs/Web/API/Window/clearTimeout):
+    /// the timeout's `callback` won't run, if it hasn't.
+    #[link_name = "clearTimeout"]
+    pub safe fn clear_timeout(id: &TimeoutId);
+
+    /// [`setInterval(callback, ms)`](https://developer.mozilla.org/docs/Web/API/Window/setInterval):
+    /// `callback` every `ms` milliseconds, until it's cleared.
+    #[link_name = "setInterval"]
+    pub safe fn set_interval(callback: Box<dyn FnMut()>, ms: u32) -> &'static IntervalId;
+
+    /// [`clearInterval(id)`](https://developer.mozilla.org/docs/Web/API/Window/clearInterval):
+    /// the interval's `callback` doesn't run again.
+    #[link_name = "clearInterval"]
+    pub safe fn clear_interval(id: &IntervalId);
+}
+
+/// A JS [`RegExp`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/RegExp),
+/// for what Rust would use the `regex` crate for. `replace` with a string is
+/// here; with a closure, and `matchAll`, are bindings a program declares, typed
+/// for its pattern: a JS replacer is given the match, then each group, then
+/// where it matched, so its Rust type is the pattern's.
+pub struct RegExp(PhantomData<JsObject>);
+
+pub mod reg_exp {
+    use super::*;
+
+    unsafe extern "Rust" {
+        /// `new RegExp(pattern, flags)`: flags like `"gm"`.
+        #[link_name = "new RegExp"]
+        pub safe fn new(pattern: &str, flags: &str) -> &'static RegExp;
+
+        #[link_name = "test"]
+        pub safe fn test(this: &RegExp, text: &str) -> bool;
+
+        /// [`text.replace(pattern, with)`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/replace):
+        /// the first match, or with the `g` flag each, replaced with `with`,
+        /// in which `$1` is the first group and `$&` the match.
+        #[link_name = "replace"]
+        pub safe fn replace(this: &str, pattern: &RegExp, with: &str) -> String;
+    }
+}
+
+/// A JS number's methods, for where Rust's own `format!` isn't what's wanted.
+pub mod number {
+    unsafe extern "Rust" {
+        /// [`x.toFixed(digits)`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed):
+        /// `x` with `digits` decimals, as JS rounds, a tie away from zero:
+        /// `2.5` is `"3"`, where `format!("{:.0}", 2.5)` is `"2"`, to even, as
+        /// Rust rounds it. Between ties they agree. `-0` is `"0"`, `1e21` and up
+        /// is `String(x)`, `"1e+21"`, and `Infinity` is `"Infinity"`, where
+        /// `format!`'s is `"inf"`. `digits` is 0 to 100: more throws a `RangeError`.
+        #[link_name = "toFixed"]
+        pub safe fn to_fixed(this: f64, digits: u32) -> String;
+    }
+}
+
+/// JS's [`JSON`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON).
+/// A Rust value's JSON is serde's (ADR 0077): `JSON.stringify` of one, as
+/// rust-js has it in JS, isn't, since `None` is `undefined` and an `i64` a
+/// `BigInt`, which it throws on. So it's typed for what it's exact for.
+pub mod json {
+    unsafe extern "Rust" {
+        /// [`JSON.stringify(text)`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify):
+        /// `text`'s JSON, in quotes, with its `"`, `\` and control characters
+        /// escaped, which is a JS string literal too.
+        #[link_name = "JSON.stringify"]
+        pub safe fn stringify(text: &str) -> String;
+    }
+}
+
+/// Whatever a JS function threw, or a promise rejected with: usually an
+/// [`Error`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error).
+/// An `extern` function that returns `Result<T, &JsError>` catches it (ADR 0035).
+pub struct JsError(PhantomData<JsObject>);
+
+pub mod js_error {
+    use super::*;
+
+    unsafe extern "Rust" {
+        /// `String(e)`: an `Error`'s name and message, or any value as text.
+        #[link_name = "String"]
+        pub safe fn to_string(error: &JsError) -> String;
+
+        /// `e instanceof Error`: what was thrown is an
+        /// [`Error`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error),
+        /// which has a `message`. A promise may be rejected with anything.
+        #[link_name = "instanceof Error"]
+        pub safe fn is_error(this: &JsError) -> bool;
+
+        /// [`e.message`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Error/message):
+        /// an `Error`'s message, without its name, as `is_error(e)` says it is one.
+        #[link_name = "get message"]
+        pub safe fn message(this: &JsError) -> String;
+    }
+}
+
+/// JS's [`Object`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)
+/// functions, for a JS object an API takes or gives.
+pub mod object {
+    use super::*;
+
+    /// [`Object.fromEntries(entries)`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries):
+    /// a JS object of these keys and values, as an API that takes a
+    /// dictionary of them wants: `{ "aria-label": "Rust source" }`.
+    #[cfg_attr(rust_js, rust_js::link_name = "Object.fromEntries")]
+    #[allow(unused_variables)]
+    pub fn from_entries<T>(entries: Vec<(String, T)>) -> &'static JsObject {
+        unreachable!()
+    }
+
+    /// [`Object.is(a, b)`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/is):
+    /// the same object, or the same value, where `NaN` is itself and `0`
+    /// isn't `-0`. Of JS objects, whether they're one: `std::ptr::eq` isn't
+    /// rust-js's. Of two Rust types too, since a JS object may be seen as
+    /// either: a message's sender, an object, and a frame's `Window`.
+    #[cfg_attr(rust_js, rust_js::link_name = "Object.is")]
+    #[allow(unused_variables)]
+    pub fn is<A: ?Sized, B: ?Sized>(a: &A, b: &B) -> bool {
+        unreachable!()
+    }
+}
+
+/// A JS [`ArrayBuffer`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer):
+/// raw bytes, as `response::array_buffer` gives them.
+pub struct ArrayBuffer(PhantomData<JsObject>);
+
+pub mod array_buffer {
+    use super::*;
+
+    unsafe extern "Rust" {
+        #[link_name = "get byteLength"]
+        pub safe fn byte_length(this: &ArrayBuffer) -> u32;
+    }
+}
+
+/// A JS [`Uint8Array`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array):
+/// a view of the bytes in an `ArrayBuffer`, as `response::bytes` gives them.
+pub struct Uint8Array(PhantomData<JsObject>);
+
+pub mod uint8_array {
+    use super::*;
+
+    unsafe extern "Rust" {
+        /// A view of all of `buffer`.
+        #[link_name = "new Uint8Array"]
+        pub safe fn new(buffer: &ArrayBuffer) -> &'static Uint8Array;
+
+        /// How many bytes it views.
+        #[link_name = "get length"]
+        pub safe fn length(this: &Uint8Array) -> u32;
+
+        /// The buffer it views.
+        #[link_name = "get buffer"]
+        pub safe fn buffer(this: &Uint8Array) -> &'static ArrayBuffer;
+    }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@rust-js/resources",
+  "version": "0.0.1",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rust-js-lang/rust-js.git"
+  },
+  "description": "Pinned build inputs for rust-js React, web, and Serde bindings.",
+  "files": [
+    "rust-toolchain.toml",
+    "react/build.sh",
+    "react/cfg.js",
+    "react/versions.json",
+    "react/src/lib.rs",
+    "react/src/event.rs",
+    "react/src/dom.rs",
+    "react/src/elements.rs",
+    "react/Cargo.toml",
+    "react/build.rs",
+    "webapi/build.sh",
+    "webapi/src/lib.rs",
+    "webapi/Cargo.toml",
+    "builtins/build.sh",
+    "builtins/src/lib.rs",
+    "builtins/Cargo.toml",
+    "serde/Cargo.toml",
+    "serde/Cargo.lock",
+    "serde/src/lib.rs"
+  ]
+}

package/react/Cargo.toml

@@ -0,0 +1,27 @@
+# The react crate as a Cargo dependency (ADR 0101): rustc checks it, as
+# react/build.sh does, for the React release `RUST_JS_REACT` names, or the
+# latest the crate knows (ADR 0043); build.rs gives its `cfg`s.
+[package]
+name = "rust-js-react"
+version = "0.0.1"
+edition = "2024"
+description = "React for rust-js: components written in Rust, compiled to the JSX you'd write"
+license = "MIT"
+repository = "https://github.com/rust-js-lang/rust-js"
+readme = "README.md"
+# Its Rust, and what build.rs reads, not the repository's tools that build
+# or generate it.
+include = ["src", "build.rs", "versions.json", "README.md"]
+build = "build.rs"
+
+[lib]
+name = "react"
+path = "src/lib.rs"
+
+[dependencies]
+js = { package = "rust-js-builtins", path = "../builtins", version = "~0.0.1" }
+webapi = { package = "rust-js-webapi", path = "../webapi", version = "~0.0.1" }
+
+# rust-js compiles with `--cfg=rust_js` (ADR 0113): a `cfg` Cargo checks for.
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ["cfg(rust_js)"] }

package/react/build.rs

@@ -0,0 +1,59 @@
+//! The react crate's `cfg`s for one React release (ADR 0043), as `cfg.js`
+//! gives `react/build.sh` them: `react="18.1"` and so on for every minor
+//! release up to `RUST_JS_REACT`, so an item gated `#[cfg(react = "19.2")]`
+//! exists only from React 19.2. The releases are `versions.json`'s.
+
+use std::path::Path;
+
+fn main() {
+    let versions = Path::new(env!("CARGO_MANIFEST_DIR")).join("versions.json");
+    println!("cargo::rerun-if-changed={}", versions.display());
+    println!("cargo::rerun-if-env-changed=RUST_JS_REACT");
+    let text = std::fs::read_to_string(&versions).expect("react/versions.json");
+    let releases = releases(&text);
+    let latest = *releases.last().expect("react/versions.json lists no release");
+    let wanted = match std::env::var("RUST_JS_REACT") {
+        Ok(version) => minor(&version).unwrap_or_else(|| panic!("RUST_JS_REACT: not a React version: {version}")),
+        Err(_) => minor(latest).expect("a release is a version"),
+    };
+    let first = minor(releases[0]).expect("a release is a version");
+    assert!(
+        first <= wanted,
+        "React {}.{} is older than {}, the first release the react crate supports",
+        wanted.0,
+        wanted.1,
+        releases[0]
+    );
+    if wanted > minor(latest).expect("a release is a version") {
+        println!(
+            "cargo::warning=React {}.{} is newer than {latest}, the latest release the react crate knows: it has {latest}'s API",
+            wanted.0, wanted.1
+        );
+    }
+    let values: Vec<String> = releases.iter().map(|release| format!("\"{release}\"")).collect();
+    println!("cargo::rustc-check-cfg=cfg(react,values({}))", values.join(","));
+    for release in releases
+        .iter()
+        .filter(|release| minor(release).is_some_and(|r| r <= wanted))
+    {
+        println!("cargo::rustc-cfg=react=\"{release}\"");
+    }
+}
+
+/// `versions.json`'s releases, `"18.0"` to the latest, as react/generate.ts
+/// writes them: the keys of its `"releases"` object, one to a line.
+fn releases(text: &str) -> Vec<&str> {
+    let start = text.find("\"releases\": {").expect("versions.json has releases");
+    let end = start + text[start..].find('}').expect("releases end");
+    text[start..end]
+        .lines()
+        .skip(1)
+        .filter_map(|line| line.trim().strip_prefix('"')?.split_once('"').map(|(key, _)| key))
+        .collect()
+}
+
+/// A version's major and minor release: `18.2.0` is `(18, 2)`.
+fn minor(version: &str) -> Option<(u32, u32)> {
+    let mut parts = version.split('.');
+    Some((parts.next()?.parse().ok()?, parts.next()?.parse().ok()?))
+}

package/react/build.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+# Compile the react crate's metadata (ADRs 0041, 0043), and the webapi and js
+# crates' beside it, which it uses:
+#
+#   react/build.sh -o target/libreact.rmeta                  # the latest React's API
+#   react/build.sh -o target/react-18.2/libreact.rmeta --react 18.2.0
+#
+# With `--react`, what later React versions added is left out, so a program
+# using it doesn't compile. Then compile a program with
+# `rust-js app.rs -- --extern react=target/libreact.rmeta -L target`.
+set -euo pipefail
+[ "${1:-}" = "-o" ] && [ -n "${2:-}" ] || {
+  echo "usage: react/build.sh -o <dir>/libreact.rmeta [--react <version>] [rustc flags]" >&2
+  exit 1
+}
+out=$2
+shift 2
+version=
+if [ "${1:-}" = "--react" ]; then
+  version=${2:?--react needs a version, like 18.2.0}
+  shift 2
+fi
+mkdir -p "$(dirname "$out")"
+dir=$(cd "$(dirname "$out")" && pwd)
+cd "$(dirname "$0")"
+cfg=()
+cfg_output=$("${RUST_JS_JS_RUNTIME:-node}" cfg.js ${version:+"$version"})
+while IFS= read -r flag; do cfg+=("$flag"); done <<< "$cfg_output"
+../webapi/build.sh -o "$dir/libwebapi.rmeta" "$@"
+# For rust-js's target (ADR 0090), unless another is given.
+target=(--target=wasm32-unknown-unknown)
+for arg in "$@"; do
+  case "$arg" in --target | --target=*) target=() ;; esac
+done
+# rust-js compiles it, as rustc with rust-js's tool, `rust_js`, known (ADR
+# 0112): $RUST_JS_COMPILER, or this repository's own build.
+compiler=${RUST_JS_COMPILER:-$PWD/../target/debug/rust-js}
+# A packaged one is a JS launcher, run by the JS runtime the build is.
+rust_js=("$compiler")
+case "$compiler" in *.js) rust_js=("${RUST_JS_JS_RUNTIME:-node}" "$compiler") ;; esac
+# The absolute path lets a program's errors quote this crate's source: a gated
+# item's `#[cfg(react = "..")]`.
+exec "${rust_js[@]}" --rustc --edition=2024 --crate-type=lib --crate-name=react --emit=metadata ${target[@]+"${target[@]}"} "$PWD/src/lib.rs" \
+  --extern webapi="$dir/libwebapi.rmeta" --extern js="$dir/libjs.rmeta" "${cfg[@]}" -o "$dir/$(basename "$out")" "$@"

package/react/cfg.js

@@ -0,0 +1,60 @@
+// The rustc flags that build the react crate for one React version (ADR 0043):
+// `--cfg react="18.1"` and so on for every minor release up to it, so an
+// item gated `#[cfg(react = "19.2")]` exists only from React 19.2.
+//
+//   node react/cfg.js 18.2.0    prints one flag per line, for react/build.sh
+//
+// The releases are react/versions.json's, which react/generate.ts reads from
+// React itself.
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const versions = JSON.parse(readFileSync(new URL("./versions.json", import.meta.url), "utf8"));
+
+export const releases = Object.keys(versions.releases);
+const lastRelease = releases.at(-1);
+if (lastRelease === undefined) throw new Error("React versions must contain at least one release");
+export const latest = lastRelease;
+
+function minor(version) {
+  const [major, minor] = version.split(".").map(Number);
+  return [major, minor];
+}
+
+function atMost(a, b) {
+  return a[0] < b[0] || (a[0] === b[0] && a[1] <= b[1]);
+}
+
+/**
+ * The flags for `version`, and a warning when it's newer than the releases
+ * the crate knows, which then gets the latest's API. Throws when it's older
+ * than the first release the crate supports.
+ */
+export function cfgFlags(version) {
+  const wanted = minor(version);
+  if (wanted.some(Number.isNaN)) throw new Error(`not a React version: ${version}`);
+  if (!atMost(minor(releases[0]), wanted)) {
+    throw new Error(`React ${version} is older than ${releases[0]}, the first release the react crate supports`);
+  }
+  const values = releases.map((r) => JSON.stringify(r)).join(",");
+  const flags = [`--check-cfg=cfg(react,values(${values}))`];
+  for (const release of releases) {
+    if (atMost(minor(release), wanted)) flags.push(`--cfg=react=${JSON.stringify(release)}`);
+  }
+  const warning = atMost(wanted, minor(latest))
+    ? undefined
+    : `React ${version} is newer than ${latest}, the latest release the react crate knows: it has ${latest}'s API`;
+  return { flags, warning };
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    const { flags, warning } = cfgFlags(process.argv[2] ?? latest);
+    if (warning) console.error(`warning: ${warning}`);
+    console.log(flags.join("\n"));
+  } catch (error) {
+    console.error(`error: ${error.message}`);
+    process.exit(1);
+  }
+}