From 17901f29093405bc57809263bd4924f1deb18ceb Mon Sep 17 00:00:00 2001 From: Sam Gammon Date: Sun, 16 Feb 2025 18:29:56 -0800 Subject: [PATCH] feat(graalvm): synthesized module loader - feat(graalvm): js realm patching - feat(graalvm): central loader registry - feat(graalvm): implement `ejs` language facade - chore(graalvm-ts): transition to engine-based utils Signed-off-by: Sam Gammon --- packages/cli/build.gradle.kts | 7 +- .../elide/tool/cli/AbstractSubcommand.kt | 2 +- .../kotlin/elide/tool/cli/EngineGuestIds.kt | 5 +- .../kotlin/elide/tool/cli/GuestLanguage.kt | 22 ++- .../control/AbstractScriptEngineFactory.kt | 5 +- packages/cli/src/main/resources/elide.yml | 2 +- packages/embedded/build.gradle.kts | 1 + packages/engine/api/engine.api | 12 ++ packages/engine/build.gradle.kts | 1 + .../runtime/gvm/loader/JSRealmPatcher.kt | 93 +++++++++++++ .../runtime/gvm/loader/LoaderRegistry.kt | 69 ++++++++++ .../runtime/plugins/AbstractLanguageConfig.kt | 72 +++++----- .../lang/typescript/JSRealmPatcher.java | 31 ----- .../lang/typescript/TypeScriptLanguage.java | 9 +- packages/graalvm/build.gradle.kts | 4 +- packages/graalvm/detekt-baseline.xml | 1 + .../core/internals/graalvm/GraalVMContext.kt | 11 +- .../core/internals/graalvm/GraalVMEngine.kt | 23 +++- .../kotlin/elide/runtime/gvm/GraalVMGuest.kt | 4 +- .../kotlin/elide/runtime/gvm/GuestLanguage.kt | 5 + .../runtime/gvm/cfg/GuestVMConfiguration.kt | 8 +- .../gvm/internals/ElideEsModuleLoader.kt | 104 ++++++++++++++ .../runtime/gvm/internals/JavaScriptLang.kt | 54 ++++++++ .../internals/intrinsics/ElideIntrinsic.kt | 4 +- .../internals/js/ElideJavaScriptLanguage.kt | 129 ++++++++++++++++++ .../internals/js/ElideJsFileTypeDetector.kt | 37 +++++ .../kotlin/elide/runtime/gvm/js/JavaScript.kt | 30 +++- .../elide/runtime/plugins/js/JavaScript.kt | 6 +- .../elide/embedded/runtime/js/facade.js | 2 +- .../elide/embedded/runtime/js/polyfills.js | 2 +- .../elide/embedded/runtime/js/runtime.json.gz | Bin 158 -> 176 bytes .../kotlin/elide/runtime/core/ContextTest.kt | 5 +- .../elide/runtime/gvm/js/AbstractJsTest.kt | 3 +- .../runtime/intrinsics/js/JsGlobalsTest.kt | 9 +- runtime | 2 +- 35 files changed, 669 insertions(+), 105 deletions(-) create mode 100644 packages/engine/src/main/kotlin/elide/runtime/gvm/loader/JSRealmPatcher.kt create mode 100644 packages/engine/src/main/kotlin/elide/runtime/gvm/loader/LoaderRegistry.kt delete mode 100644 packages/graalvm-ts/src/main/java/elide/runtime/lang/typescript/JSRealmPatcher.java create mode 100644 packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/ElideEsModuleLoader.kt create mode 100644 packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/JavaScriptLang.kt create mode 100644 packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/js/ElideJavaScriptLanguage.kt create mode 100644 packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/js/ElideJsFileTypeDetector.kt diff --git a/packages/cli/build.gradle.kts b/packages/cli/build.gradle.kts index 75c2ec82c..17bd08b00 100644 --- a/packages/cli/build.gradle.kts +++ b/packages/cli/build.gradle.kts @@ -683,6 +683,7 @@ val enabledSecurityProviders = listOfNotNull( val preinitializedContexts = if (!enablePreinit) emptyList() else listOfNotNull( "js", + "ejs", // ElideJS onlyIf(enablePreinitializeAll && enableRuby, "ruby"), onlyIf(enablePreinitializeAll && enablePython, "python"), onlyIf(enablePreinitializeAll && enableJvm, "java"), @@ -884,7 +885,7 @@ val releaseFlags: List = listOf( if (oracleGvm) gvmReleaseFlags else emptyList(), ).flatten()).toList() -val jvmDefs = mapOf( +val jvmDefs = mutableMapOf( "elide.strict" to "true", "elide.natives" to nativesPath, "elide.target" to targetPath.asFile.path, @@ -916,6 +917,10 @@ val jvmDefs = mapOf( // "java.util.concurrent.ForkJoinPool.common.exceptionHandler" to "", ) +findProperty("elide.logLevel")?.let { + jvmDefs["elide.logging.root.level"] = it as String +} + val hostedRuntimeOptions = mapOf( "IncludeLocales" to "en", ) diff --git a/packages/cli/src/main/kotlin/elide/tool/cli/AbstractSubcommand.kt b/packages/cli/src/main/kotlin/elide/tool/cli/AbstractSubcommand.kt index 6cb7abdd9..880dd9163 100644 --- a/packages/cli/src/main/kotlin/elide/tool/cli/AbstractSubcommand.kt +++ b/packages/cli/src/main/kotlin/elide/tool/cli/AbstractSubcommand.kt @@ -99,7 +99,7 @@ import org.graalvm.polyglot.Engine as VMEngine logging.trace("Language '${it.name}' is supported") supported to it } - }.flatMap { (guest, lang) -> + }.distinctBy { it.first.id }.flatMap { (guest, lang) -> listOf(guest to lang) + additionalEnginesByLang[guest]?.map { additional -> additional to lang }.orEmpty() diff --git a/packages/cli/src/main/kotlin/elide/tool/cli/EngineGuestIds.kt b/packages/cli/src/main/kotlin/elide/tool/cli/EngineGuestIds.kt index 279d58235..e451b37e0 100644 --- a/packages/cli/src/main/kotlin/elide/tool/cli/EngineGuestIds.kt +++ b/packages/cli/src/main/kotlin/elide/tool/cli/EngineGuestIds.kt @@ -14,7 +14,7 @@ package elide.tool.cli /** GraalVM engine name for GraalJs. */ -const val ENGINE_JS = "js" +const val ENGINE_JS = "ejs" /** GraalVM engine name for GraalPython. */ const val ENGINE_PYTHON = "python" @@ -28,5 +28,8 @@ const val ENGINE_JVM = "java" /** GraalVM engine name for GraalWasm. */ const val ENGINE_WASM = "wasm" +/** GraalVM engine name for Pkl. */ +const val ENGINE_PKL = "pkl" + /** GraalVM engine name for GraalLLVM. */ const val ENGINE_LLVM = "llvm" diff --git a/packages/cli/src/main/kotlin/elide/tool/cli/GuestLanguage.kt b/packages/cli/src/main/kotlin/elide/tool/cli/GuestLanguage.kt index 97f805bc0..4bc65d726 100644 --- a/packages/cli/src/main/kotlin/elide/tool/cli/GuestLanguage.kt +++ b/packages/cli/src/main/kotlin/elide/tool/cli/GuestLanguage.kt @@ -15,6 +15,8 @@ package elide.tool.cli +import elide.runtime.gvm.internals.js.ELIDE_JS_LANGUAGE_ID + /** Specifies languages supported for REPL access. */ enum class GuestLanguage ( internal val id: String, @@ -28,6 +30,7 @@ enum class GuestLanguage ( internal val dependsOn: List = emptyList(), internal val executionMode: ExecutionMode = ExecutionMode.SOURCE_DIRECT, internal val secondary: Boolean = dependsOn.isNotEmpty(), + override val requestId: String = engine, ) : elide.runtime.gvm.GuestLanguage, elide.runtime.core.GuestLanguage { /** Interactive JavaScript VM. */ JS ( @@ -37,6 +40,7 @@ enum class GuestLanguage ( onByDefault = true, extensions = listOf("js", "cjs", "mjs"), mimeTypes = listOf("application/javascript", "application/javascript+module", "application/ecmascript"), + requestId = ELIDE_JS_LANGUAGE_ID, ), /** JavaScript VM enabled with TypeScript support. */ @@ -132,7 +136,7 @@ enum class GuestLanguage ( dependsOn = listOf(JVM), ), - /** Interactive nested JVM. */ + /** WebAssembly. */ WASM ( id = ENGINE_WASM, formalName = "WASM", @@ -140,29 +144,41 @@ enum class GuestLanguage ( suppressExperimentalWarning = true, extensions = listOf("wasm"), mimeTypes = listOf("application/wasm"), + ), + + /** Apple Pkl. */ + PKL ( + id = ENGINE_PKL, + formalName = "Pkl", + experimental = true, + suppressExperimentalWarning = true, + extensions = listOf("pkl"), + mimeTypes = listOf("application/pkl"), ); companion object { /** @return Language based on the provided ID, or `null`. */ internal fun resolveFromEngine(id: String): GuestLanguage? = when (id) { - JS.engine -> JS + JS.engine, ELIDE_JS_LANGUAGE_ID -> JS TYPESCRIPT.engine -> TYPESCRIPT PYTHON.engine -> PYTHON RUBY.engine -> RUBY JVM.engine -> JVM WASM.engine -> WASM LLVM.engine -> LLVM + PKL.engine -> PKL else -> null } /** @return Language based on the provided ID, or `null`. */ internal fun resolveFromId(id: String): GuestLanguage? = when (id) { - JS.id -> JS + JS.id, ELIDE_JS_LANGUAGE_ID -> JS PYTHON.id -> PYTHON RUBY.id -> RUBY JVM.id -> JVM WASM.id -> WASM LLVM.id -> LLVM + PKL.id -> PKL TYPESCRIPT.id -> TYPESCRIPT // JVM extension guests diff --git a/packages/cli/src/main/kotlin/elide/tool/control/AbstractScriptEngineFactory.kt b/packages/cli/src/main/kotlin/elide/tool/control/AbstractScriptEngineFactory.kt index 59af33830..d3711c43e 100644 --- a/packages/cli/src/main/kotlin/elide/tool/control/AbstractScriptEngineFactory.kt +++ b/packages/cli/src/main/kotlin/elide/tool/control/AbstractScriptEngineFactory.kt @@ -29,7 +29,8 @@ abstract class AbstractScriptEngineFactory protected constructor (val engine: Gr private val polyglotEngine = Engine.newBuilder().build() } - private val languageId: String = engine.engine + private val languageId: String = engine.requestId + private val language by lazy { requireNotNull(polyglotEngine.languages[languageId]) { "Failed to resolve language implementation with ID $languageId" @@ -236,7 +237,7 @@ abstract class AbstractScriptEngineFactory protected constructor (val engine: Gr } } - private class PolyglotContext (private val languageId: String) : ScriptContext { + private class PolyglotContext constructor (private val languageId: String) : ScriptContext { private var context: Context? = null private val `in`: PolyglotReader private val out: PolyglotWriter diff --git a/packages/cli/src/main/resources/elide.yml b/packages/cli/src/main/resources/elide.yml index 2bd891405..4135d7576 100644 --- a/packages/cli/src/main/resources/elide.yml +++ b/packages/cli/src/main/resources/elide.yml @@ -1,7 +1,7 @@ elide: gvm: enabled: true - languages: ["JS"] + languages: ["EJS"] defer: true js: enabled: true diff --git a/packages/embedded/build.gradle.kts b/packages/embedded/build.gradle.kts index 4d18596f9..77ef207f8 100644 --- a/packages/embedded/build.gradle.kts +++ b/packages/embedded/build.gradle.kts @@ -87,6 +87,7 @@ val sharedLibArgs = sequenceOf( "-J-Dpolyglot.image-build-time.PreinitializeContextsWithNative=true", "-J-Dpolyglot.image-build-time.PreinitializeContexts=" + listOfNotNull( "js", + "ejs", ).joinToString(","), ) diff --git a/packages/engine/api/engine.api b/packages/engine/api/engine.api index 69827aaa7..29d19ebab 100644 --- a/packages/engine/api/engine.api +++ b/packages/engine/api/engine.api @@ -366,6 +366,18 @@ public final class elide/runtime/gvm/cfg/LanguageDefaults { public final fun getDEFAULT_TIMEZONE ()Ljava/time/ZoneId; } +public final class elide/runtime/gvm/loader/JSRealmPatcher { + public static final field INSTANCE Lelide/runtime/gvm/loader/JSRealmPatcher; + public final fun getModuleLoaderField ()Ljava/lang/reflect/Field; +} + +public final class elide/runtime/gvm/loader/LoaderRegistry { + public static final field INSTANCE Lelide/runtime/gvm/loader/LoaderRegistry; + public static final fun mountPrimary (Lcom/oracle/truffle/js/runtime/JSRealm;Lcom/oracle/truffle/js/runtime/objects/JSModuleLoader;)V + public static final fun register (Lcom/oracle/truffle/js/runtime/JSRealm;Lcom/oracle/truffle/js/runtime/objects/JSModuleLoader;)V + public static final fun register (Lcom/oracle/truffle/js/runtime/objects/JSModuleLoader;)V +} + public abstract class elide/runtime/plugins/AbstractLanguageConfig { public static final field Companion Lelide/runtime/plugins/AbstractLanguageConfig$Companion; public fun ()V diff --git a/packages/engine/build.gradle.kts b/packages/engine/build.gradle.kts index 4c54e6ced..db2dbbad3 100644 --- a/packages/engine/build.gradle.kts +++ b/packages/engine/build.gradle.kts @@ -56,6 +56,7 @@ dependencies { api(libs.graalvm.polyglot) api(libs.kotlinx.coroutines.core) api(libs.guava) + api(libs.graalvm.js.language) implementation(libs.kotlinx.serialization.core) implementation(libs.kotlinx.serialization.json) diff --git a/packages/engine/src/main/kotlin/elide/runtime/gvm/loader/JSRealmPatcher.kt b/packages/engine/src/main/kotlin/elide/runtime/gvm/loader/JSRealmPatcher.kt new file mode 100644 index 000000000..b8e7fa1a1 --- /dev/null +++ b/packages/engine/src/main/kotlin/elide/runtime/gvm/loader/JSRealmPatcher.kt @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2024 Elide Technologies, Inc. + * + * Licensed under the MIT license (the "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://opensource.org/license/mit/ + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under the License. + */ +package elide.runtime.gvm.loader + +import com.oracle.truffle.js.builtins.commonjs.NpmCompatibleESModuleLoader +import com.oracle.truffle.js.runtime.JSRealm +import com.oracle.truffle.js.runtime.objects.JSModuleLoader +import java.lang.reflect.Field + +/** + * # JS Realm Patcher + * + * Internal utilities for patching the root JavaScript realm. + */ +public object JSRealmPatcher { + // Resolved field for the root JS realm's module loader. + @PublishedApi internal val moduleLoaderField: Field by lazy { + try { + JSRealm::class.java.getDeclaredField("moduleLoader").also { + it.isAccessible = true + } + } catch (e: NoSuchFieldException) { + throw IllegalStateException("Failed to resolve `moduleLoader` field from `JSRealm`", e) + } catch (e: IllegalAccessException) { + throw IllegalStateException("Failed to forcibly allow access to `moduleLoader` field from `JSRealm`", e) + } + } + + /** + * Override the current [JSModuleLoader] with a wrapped instance, based on the [Base] loader type; the returned + * [Loader] type is the overridden loader, which is expected to wrap the base loader. + * + * Under the hood, this method simply calls [getModuleLoader], then the [prepare] factory, then [installModuleLoader]. + * + * @param jsRealm The JS realm to override the module loader in. + * @param prepare The factory to prepare the new loader instance. + * @return The overridden loader instance. + */ + public inline fun overrideLoader( + jsRealm: JSRealm, + crossinline prepare: (Base) -> Loader, + ): Loader = getModuleLoader(jsRealm).let { baseLoader -> + prepare(baseLoader).also { loader -> + installModuleLoader(jsRealm, loader) + } + } + + /** + * Retrieve the current [JSModuleLoader] from the provided [jsRealm]. + * + * This method will throw if: + * - The loader is not available because its field is set to `null`. + * - The loader is not an instance of the expected type. + * + * @param jsRealm The JS realm to retrieve the module loader from. + * @return The module loader instance. + * @throws IllegalStateException If the module loader is not available or is not an instance of the expected type. + */ + public inline fun getModuleLoader(jsRealm: JSRealm): Loader { + return (moduleLoaderField[jsRealm] ?: NpmCompatibleESModuleLoader.create(jsRealm)).also { + require(it is Loader) { + "Failed to cast `moduleLoader` field from `JSRealm` to `${Loader::class.java.simpleName}`" + } + } as Loader + } + + /** + * Forcibly install the specified [moduleLoader] from the provided [jsRealm]. + * + * This method will throw if: + * - The field cannot be resolved (on first access). + * - The loader cannot be set because its field is not accessible. + * + * @param jsRealm The JS realm to install the module loader into. + * @throws IllegalStateException If the module loader install step fails. + */ + public inline fun installModuleLoader(jsRealm: JSRealm, moduleLoader: Loader,) { + val current = moduleLoaderField[jsRealm] + if (current !== moduleLoader) { + moduleLoaderField[jsRealm] = moduleLoader + } + } +} diff --git a/packages/engine/src/main/kotlin/elide/runtime/gvm/loader/LoaderRegistry.kt b/packages/engine/src/main/kotlin/elide/runtime/gvm/loader/LoaderRegistry.kt new file mode 100644 index 000000000..a8e9843cc --- /dev/null +++ b/packages/engine/src/main/kotlin/elide/runtime/gvm/loader/LoaderRegistry.kt @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2024 Elide Technologies, Inc. + * + * Licensed under the MIT license (the "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://opensource.org/license/mit/ + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under the License. + */ +package elide.runtime.gvm.loader + +import com.oracle.truffle.js.runtime.JSRealm +import com.oracle.truffle.js.runtime.objects.JSModuleLoader +import java.lang.ref.WeakReference +import java.util.LinkedList +import java.util.concurrent.ConcurrentHashMap + +/** + * # Loader Registry + * + * Static utility for registering [JSModuleLoader]-compliant implementations, and similar objects for other languages; + * these registered objects are consulted from delegated Elide types. + */ +public object LoaderRegistry { + // Registered JavaScript module loaders. + @JvmStatic private val rootEsLoaders = LinkedList() + + // Registered JavaScript Realm-specific module loaders. + @JvmStatic private val realmBoundEsLoaders = ConcurrentHashMap>>() + + /** + * Register a JavaScript module loader. + * + * @param loader The JavaScript module loader to register. + */ + @JvmStatic public fun register(loader: JSModuleLoader) { + rootEsLoaders.add(loader) + } + + /** + * Register a JavaScript module loader. + * + * @param realm JavaScript realm to bind this loader to. + * @param loader The JavaScript module loader to register. + */ + @JvmStatic public fun register(realm: JSRealm, loader: JSModuleLoader) { + val bound = realmBoundEsLoaders.computeIfAbsent(realm) { LinkedList() } + bound.add(WeakReference(loader)) + } + + /** + * Mount the provided module [loader] forcibly as the main loader for a given JavaScript [realm]. + * + * @param realm The JavaScript realm to mount the loader to. + * @param loader The JavaScript module loader to mount. + */ + @JvmStatic public fun mountPrimary(realm: JSRealm, loader: JSModuleLoader) { + if (realm.parent == null) { + register(loader) + } + register(realm, loader) // associate with realm, too + JSRealmPatcher.overrideLoader(realm) { + loader + } + } +} diff --git a/packages/engine/src/main/kotlin/elide/runtime/plugins/AbstractLanguageConfig.kt b/packages/engine/src/main/kotlin/elide/runtime/plugins/AbstractLanguageConfig.kt index 959049010..d96e638f5 100644 --- a/packages/engine/src/main/kotlin/elide/runtime/plugins/AbstractLanguageConfig.kt +++ b/packages/engine/src/main/kotlin/elide/runtime/plugins/AbstractLanguageConfig.kt @@ -27,7 +27,7 @@ import elide.runtime.core.PolyglotContext */ @DelicateElideApi public abstract class AbstractLanguageConfig { public companion object { - private const val EXPERIMENTAL_SECURE_INTERNALS = true + private const val EXPERIMENTAL_SECURE_INTERNALS = false } /** Mutable counterpart to [intrinsicBindings]. */ @@ -80,42 +80,40 @@ import elide.runtime.core.PolyglotContext // in languages based on JS, we expose a special object, `primordials`, for internal evaluations only // @TODO don't hard-code this - if (language?.languageId == "js") { - putMember("primordials", object : ProxyObject, ProxyHashMap { - override fun getMemberKeys(): Array = internalKeys - override fun hasMember(key: String?): Boolean = key != null && key in internalKeys - override fun hasHashEntry(key: Value?): Boolean = key != null && key.asString() in internalKeys - override fun getHashSize(): Long = internalKeys.size.toLong() - - override fun putMember(key: String?, value: Value?) { - // no-op - } - - override fun putHashEntry(key: Value?, value: Value?) { - // no-op - } - - override fun removeMember(key: String?): Boolean { - return false // not supported - } - - override fun removeHashEntry(key: Value?): Boolean { - return false // not supported - } - - override fun getMember(key: String?): Any? = when (key) { - null -> null - else -> internals[key] - } - - override fun getHashValue(key: Value?): Any? = when (key) { - null -> null - else -> internals[key.asString()] - } - - override fun getHashEntriesIterator(): Any = internals.iterator() - }) - } + putMember("primordials", object : ProxyObject, ProxyHashMap { + override fun getMemberKeys(): Array = internalKeys + override fun hasMember(key: String?): Boolean = key != null && key in internalKeys + override fun hasHashEntry(key: Value?): Boolean = key != null && key.asString() in internalKeys + override fun getHashSize(): Long = internalKeys.size.toLong() + + override fun putMember(key: String?, value: Value?) { + // no-op + } + + override fun putHashEntry(key: Value?, value: Value?) { + // no-op + } + + override fun removeMember(key: String?): Boolean { + return false // not supported + } + + override fun removeHashEntry(key: Value?): Boolean { + return false // not supported + } + + override fun getMember(key: String?): Any? = when (key) { + null -> null + else -> internals[key] + } + + override fun getHashValue(key: Value?): Any? = when (key) { + null -> null + else -> internals[key.asString()] + } + + override fun getHashEntriesIterator(): Any = internals.iterator() + }) } } } diff --git a/packages/graalvm-ts/src/main/java/elide/runtime/lang/typescript/JSRealmPatcher.java b/packages/graalvm-ts/src/main/java/elide/runtime/lang/typescript/JSRealmPatcher.java deleted file mode 100644 index 77c7d9fa7..000000000 --- a/packages/graalvm-ts/src/main/java/elide/runtime/lang/typescript/JSRealmPatcher.java +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (c) 2024 Elide Technologies, Inc. - * - * Licensed under the MIT license (the "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * https://opensource.org/license/mit/ - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on - * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the - * License for the specific language governing permissions and limitations under the License. - */ -package elide.runtime.lang.typescript; - -import com.oracle.truffle.js.runtime.JSRealm; -import java.lang.reflect.Field; - -class JSRealmPatcher { - public static void setTSModuleLoader(JSRealm jsRealm, TypeScriptModuleLoader newModuleLoader) { - try { - Field moduleLoaderField = JSRealm.class.getDeclaredField("moduleLoader"); - moduleLoaderField.setAccessible(true); - Object moduleLoader = moduleLoaderField.get(jsRealm); - if (!(moduleLoader instanceof TypeScriptModuleLoader)) { - moduleLoaderField.set(jsRealm, newModuleLoader); - } - } catch (NoSuchFieldException | IllegalAccessException e) { - assert false; - } - } -} diff --git a/packages/graalvm-ts/src/main/java/elide/runtime/lang/typescript/TypeScriptLanguage.java b/packages/graalvm-ts/src/main/java/elide/runtime/lang/typescript/TypeScriptLanguage.java index 647353876..698c17de3 100644 --- a/packages/graalvm-ts/src/main/java/elide/runtime/lang/typescript/TypeScriptLanguage.java +++ b/packages/graalvm-ts/src/main/java/elide/runtime/lang/typescript/TypeScriptLanguage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Elide Technologies, Inc. + * Copyright (c) 2024-2025 Elide Technologies, Inc. * * Licensed under the MIT license (the "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at @@ -23,6 +23,7 @@ import com.oracle.truffle.js.lang.JavaScriptLanguage; import com.oracle.truffle.js.runtime.JSEngine; import com.oracle.truffle.js.runtime.JSRealm; +import elide.runtime.gvm.loader.LoaderRegistry; import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; import org.graalvm.polyglot.SandboxPolicy; @@ -84,7 +85,8 @@ protected JSRealm createContext(Env currentEnv) { } var ctx = JSEngine.createJSContext(js, jsEnv); var realm = ctx.createRealm(jsEnv); - JSRealmPatcher.setTSModuleLoader(realm, new TypeScriptModuleLoader(realm, tsCompiler)); + final TypeScriptModuleLoader loader = new TypeScriptModuleLoader(realm, tsCompiler); + LoaderRegistry.mountPrimary(realm, loader); return realm; } @@ -118,7 +120,8 @@ protected TSRootNode(TruffleLanguage language, RootNode delegate) { @TruffleBoundary private void setModuleLoader() { JSRealm realm = JSRealm.get(delegate); - JSRealmPatcher.setTSModuleLoader(realm, new TypeScriptModuleLoader(realm, tsCompiler)); + final TypeScriptModuleLoader loader = new TypeScriptModuleLoader(realm, tsCompiler); + LoaderRegistry.mountPrimary(realm, loader); } @Override diff --git a/packages/graalvm/build.gradle.kts b/packages/graalvm/build.gradle.kts index 9fcdbdbbc..95eee5a34 100644 --- a/packages/graalvm/build.gradle.kts +++ b/packages/graalvm/build.gradle.kts @@ -56,7 +56,6 @@ val enableTransportV2 = false val ktCompilerArgs = emptyList() val javacArgs = listOf( "--add-exports=java.base/jdk.internal.module=ALL-UNNAMED", - "--add-exports=org.graalvm.nativeimage.builder/com.oracle.svm.core.jdk", "--add-exports=org.graalvm.nativeimage.builder/com.oracle.svm.hosted=ALL-UNNAMED", "--add-exports=org.graalvm.nativeimage.builder/com.oracle.svm.hosted.c=ALL-UNNAMED", ) @@ -431,8 +430,9 @@ if (enableBenchmarks) { } dependencies { - // KSP + // KSP/KSP kapt(mn.micronaut.inject.java) + kapt(libs.graalvm.truffle.processor) // API Deps api(libs.jakarta.inject) diff --git a/packages/graalvm/detekt-baseline.xml b/packages/graalvm/detekt-baseline.xml index 3bb9c2925..c56428449 100644 --- a/packages/graalvm/detekt-baseline.xml +++ b/packages/graalvm/detekt-baseline.xml @@ -113,5 +113,6 @@ UnusedPrivateMember:HttpServerAgent.kt$HttpServerAgent.Companion$private fun resolveLanguage(source: Source): GuestLanguage UnusedPrivateMember:NativeCryptoFeature.kt$NativeCryptoFeature$private fun renameNativeCryptoLib(lib: String): String UnusedPrivateProperty:AbstractJsIntrinsicTest.kt$AbstractJsIntrinsicTest$private val testInject: Boolean = true + UnusedPrivateProperty:JavaScriptLang.kt$JavaScriptLang$/** * TBD. */ @JvmStatic private val SYMBOL_ELIDE: Symbol = Symbol.createPrivate(ELIDE) diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/core/internals/graalvm/GraalVMContext.kt b/packages/graalvm/src/main/kotlin/elide/runtime/core/internals/graalvm/GraalVMContext.kt index ac074a804..63890d828 100644 --- a/packages/graalvm/src/main/kotlin/elide/runtime/core/internals/graalvm/GraalVMContext.kt +++ b/packages/graalvm/src/main/kotlin/elide/runtime/core/internals/graalvm/GraalVMContext.kt @@ -12,11 +12,14 @@ */ package elide.runtime.core.internals.graalvm +import com.oracle.truffle.js.lang.JavaScriptLanguage import org.graalvm.polyglot.Context import org.graalvm.polyglot.Source import java.util.concurrent.ConcurrentHashMap import elide.runtime.core.* import elide.runtime.core.PolyglotContext.EvaluationOptions +import elide.runtime.gvm.internals.js.ELIDE_JS_LANGUAGE_ID +import elide.runtime.gvm.internals.js.ELIDE_TS_LANGUAGE_ID /** * An implementation of the [PolyglotContext] interface wrapping a GraalVM context. @@ -36,7 +39,13 @@ import elide.runtime.core.PolyglotContext.EvaluationOptions } override fun bindings(language: GuestLanguage?): PolyglotValue { - return language?.let { context.getBindings(it.languageId) } ?: context.polyglotBindings + return language?.let { + // special case: if bindings are requested for typescript or elide JS, we return the bindings for pure JS. + when (it.languageId) { + ELIDE_JS_LANGUAGE_ID, ELIDE_TS_LANGUAGE_ID -> context.getBindings(JavaScriptLanguage.ID) + else -> context.getBindings(it.languageId) + } + } ?: context.polyglotBindings } override fun parse(source: Source): PolyglotValue { diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/core/internals/graalvm/GraalVMEngine.kt b/packages/graalvm/src/main/kotlin/elide/runtime/core/internals/graalvm/GraalVMEngine.kt index e026647b0..3d9f2ea6e 100644 --- a/packages/graalvm/src/main/kotlin/elide/runtime/core/internals/graalvm/GraalVMEngine.kt +++ b/packages/graalvm/src/main/kotlin/elide/runtime/core/internals/graalvm/GraalVMEngine.kt @@ -14,6 +14,7 @@ package elide.runtime.core.internals.graalvm +import com.oracle.truffle.js.lang.JavaScriptLanguage import org.graalvm.nativeimage.ImageInfo import org.graalvm.nativeimage.Platform import org.graalvm.polyglot.Context @@ -42,6 +43,7 @@ import elide.runtime.core.internals.MutableEngineLifecycle import elide.runtime.core.internals.graalvm.GraalVMEngine.Companion.create import elide.runtime.core.internals.graalvm.GraalVMRuntime.Companion.GVM_23 import elide.runtime.core.internals.graalvm.GraalVMRuntime.Companion.GVM_23_1 +import elide.runtime.gvm.internals.js.ElideJavaScriptLanguage import elide.vm.annotations.Polyglot import org.graalvm.polyglot.HostAccess as PolyglotHostAccess @@ -123,7 +125,7 @@ import org.graalvm.polyglot.HostAccess as PolyglotHostAccess // Finalize a suite of bindings for a given language (or the main polyglot bindings). private fun finalizeBindings(bindings: Value) { - if (bindings.hasMembers()) { + if (EXPERIMENTAL_DROP_INTERNALS && bindings.hasMembers()) { knownInternalMembers.forEach { try { bindings.removeMember(it) @@ -150,7 +152,6 @@ import org.graalvm.polyglot.HostAccess as PolyglotHostAccess private fun GraalVMContext.finalizeContext(): GraalVMContext = apply { try { context.enter() - // emit context finalization lifecycle.emit(ContextFinalized, this) doFinalize(this) @@ -218,7 +219,7 @@ import org.graalvm.polyglot.HostAccess as PolyglotHostAccess private const val ENABLE_AUX_CACHE = false /** Whether to drop internals from the polyglot context before finalization completes. */ - private const val EXPERIMENTAL_DROP_INTERNALS = true + private const val EXPERIMENTAL_DROP_INTERNALS = false /** Whether internal symbols should be withheld from guest code. */ private val shouldDropInternals = System.getProperty("elide.internals") != "true" @@ -251,7 +252,19 @@ import org.graalvm.polyglot.HostAccess as PolyglotHostAccess @Suppress("SpreadOperator", "LongMethod") public fun create(configuration: GraalVMConfiguration, lifecycle: MutableEngineLifecycle): GraalVMEngine { val nativesPath = System.getProperty("elide.natives")?.ifBlank { null } ?: defaultAuxPath - val languages = configuration.languages.map { it.languageId }.toTypedArray() + val languages = configuration.languages.flatMap { + when (it.languageId) { + ElideJavaScriptLanguage.ID, + ElideJavaScriptLanguage.TYPESCRIPT, + JavaScriptLanguage.ID -> listOf( + ElideJavaScriptLanguage.ID, + ElideJavaScriptLanguage.TYPESCRIPT, + JavaScriptLanguage.ID, + ) + + else -> listOf(it.languageId) + } + }.distinct().toTypedArray() val builder = Engine.newBuilder(*languages).apply { useSystemProperties(false) @@ -329,7 +342,7 @@ import org.graalvm.polyglot.HostAccess as PolyglotHostAccess if (useAuxCache && nativesPath != null) { // if we're running in a native image, enabled the code compile cache - // option("engine.PreinitializeContexts", "js") + // option("engine.PreinitializeContexts", "ejs") // option("engine.CacheCompile", "hot") option("engine.TraceCache", "true") disableOption("engine.CachePreinitializeContext") diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/GraalVMGuest.kt b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/GraalVMGuest.kt index fed51e503..a81d3006e 100644 --- a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/GraalVMGuest.kt +++ b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/GraalVMGuest.kt @@ -13,17 +13,19 @@ package elide.runtime.gvm import java.util.* +import elide.runtime.gvm.internals.js.ELIDE_JS_LANGUAGE_ID /** Enumerates known/supported GraalVM guest languages. */ public enum class GraalVMGuest ( override val symbol: String, override val engine: String = symbol, override val label: String, + override val requestId: String = symbol, ) : GuestLanguage { /** * ECMA2022-compliant JavaScript via Graal JS+JVM. */ - JAVASCRIPT(symbol = "js", label = "JavaScript") { + JAVASCRIPT(requestId = ELIDE_JS_LANGUAGE_ID, symbol = "js", label = "JavaScript") { override val supportsSSR: Boolean get() = true override val supportsStreamingSSR: Boolean get() = true override val invocationModes: EnumSet get() = EnumSet.allOf(InvocationMode::class.java) diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/GuestLanguage.kt b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/GuestLanguage.kt index 339afee60..9986dd81f 100644 --- a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/GuestLanguage.kt +++ b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/GuestLanguage.kt @@ -23,6 +23,11 @@ public interface GuestLanguage { */ public val symbol: String + /** + * TBD. + */ + public val requestId: String + /** * TBD. */ diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/cfg/GuestVMConfiguration.kt b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/cfg/GuestVMConfiguration.kt index 2ea511278..70a442c2f 100644 --- a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/cfg/GuestVMConfiguration.kt +++ b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/cfg/GuestVMConfiguration.kt @@ -34,7 +34,7 @@ public interface GuestVMConfiguration : Toggleable { public const val DEFAULT_ENABLED: Boolean = true /** JavaScript language tag. */ - public const val LANGUAGE_JS: String = "js" + public const val LANGUAGE_EJS: String = "ejs" /** WASM language tag. */ public const val LANGUAGE_WASM: String = "wasm" @@ -48,13 +48,17 @@ public interface GuestVMConfiguration : Toggleable { /** Java language tag. */ public const val LANGUAGE_JAVA: String = "java" + /** Pkl language tag. */ + public const val LANGUAGE_PKL: String = "pkl" + /** Default guest languages. */ public val DEFAULT_LANGUAGES: List = listOf( - LANGUAGE_JS, + LANGUAGE_EJS, LANGUAGE_WASM, LANGUAGE_PYTHON, LANGUAGE_RUBY, LANGUAGE_JAVA, + LANGUAGE_PKL, ) /** Default character set to use with raw data exchanged with the JS VM. */ diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/ElideEsModuleLoader.kt b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/ElideEsModuleLoader.kt new file mode 100644 index 000000000..bc87a9c8f --- /dev/null +++ b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/ElideEsModuleLoader.kt @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2024-2025 Elide Technologies, Inc. + * + * Licensed under the MIT license (the "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://opensource.org/license/mit/ + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under the License. + */ +package elide.runtime.gvm.internals + +import com.oracle.js.parser.ir.Module.ModuleRequest +import com.oracle.truffle.api.source.Source +import com.oracle.truffle.js.runtime.JSRealm +import com.oracle.truffle.js.runtime.objects.* +import org.graalvm.polyglot.proxy.ProxyObject +import kotlinx.atomicfu.atomic +import elide.runtime.gvm.loader.JSRealmPatcher + +private const val DENO_MODULE_PREFIX = "deno" +private const val BUN_MODULE_PREFIX = "bun" +private const val NODE_MODULE_PREFIX = "node" +private const val ELIDE_MODULE_PREFIX = "elide" + +// Implements Elide's internal ECMA-compliant module loader. +internal class ElideEsModuleLoader private constructor ( + @Suppress("unused") private val realm: JSRealm, + private val base: DefaultESModuleLoader, +) : JSModuleLoader { + // Qualifies the type of synthesized module, as applicable. + enum class ModuleQualifier { + DENO, + BUN, + NODE, + ELIDE, + } + + // Module record which holds a synthesized module object. + inner class ElideSynthesizedModuleRecord (qualifier: ModuleQualifier, data: JSModuleData, module: ProxyObject) + : JSModuleRecord(data, this, module) + + override fun loadModule(moduleSource: Source?, moduleData: JSModuleData): JSModuleRecord { +// moduleData. + val ret = base.loadModule(moduleSource, moduleData) +// JSModuleRecord(moduleData, this, null) + return ret + } + + override fun resolveImportedModule( + referencingModule: ScriptOrModule?, + moduleRequest: ModuleRequest, + ): JSModuleRecord { +// val moduleName = moduleRequest.specifier.toString() +// when (if (':' in moduleName) moduleName.substringBefore(':') else null) { +// DENO_MODULE_PREFIX -> ModuleQualifier.DENO +// BUN_MODULE_PREFIX -> ModuleQualifier.BUN +// NODE_MODULE_PREFIX -> ModuleQualifier.NODE +// ELIDE_MODULE_PREFIX -> ModuleQualifier.ELIDE +// else -> null +// }.let { qualifier -> +// when (qualifier) { +// null -> null +// else -> ElideSynthesizedModuleRecord(qualifier,) +// } +// } + + val ret = base.resolveImportedModule(referencingModule, moduleRequest) + return ret + } + + companion object { + // Whether the loader has been installed in the root realm yet. + private val installed = atomic(false) + + // Registered singleton holder. + private lateinit var singleton: ElideEsModuleLoader + + // Install the module loader and return it. + @JvmStatic private fun install(realm: JSRealm): ElideEsModuleLoader = + when (installed.compareAndSet(false, true)) { + false -> singleton + true -> synchronized(this) { + JSRealmPatcher.overrideLoader(realm) { base -> + ElideEsModuleLoader(realm, base).also { + singleton = it + } + } + } + } + + /** + * Lazily initialize Elide's ES module loader singleton; install it to the provided [realm] if needed. + * + * If the loader has already been installed, this method will return the singleton instance. + * + * @param realm The realm to install the loader to. + * @return The ES module loader singleton. + */ + @JvmStatic fun obtain(realm: JSRealm): ElideEsModuleLoader = install(realm) + } +} diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/JavaScriptLang.kt b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/JavaScriptLang.kt new file mode 100644 index 000000000..ee5e4f661 --- /dev/null +++ b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/JavaScriptLang.kt @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2024-2025 Elide Technologies, Inc. + * + * Licensed under the MIT license (the "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://opensource.org/license/mit/ + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under the License. + */ +package elide.runtime.gvm.internals + +import com.oracle.truffle.api.nodes.Node +import com.oracle.truffle.js.lang.JavaScriptLanguage +import com.oracle.truffle.js.runtime.JSRealm +import kotlinx.atomicfu.atomic +import elide.runtime.Logging +import elide.runtime.gvm.loader.JSRealmPatcher + +// Access to GraalJs internals and other types. +internal object JavaScriptLang { + private val logging by lazy { Logging.of(JavaScriptLang::class) } + + // Whether JavaScript language extensions have initialized. + private val initialized = atomic(false) + + // Initialize JavaScript language tooling; called early in JavaScript's init lifecycle. + fun initialize() { + if (initialized.compareAndSet(false, true)) { + // force the lang to initialize, as applicable + val realm = JavaScriptLanguage.getCurrentJSRealm() + assert(realm != null) { "JavaScript language failed to initialize" } + realm.bootstrap(root = true) + } + } + + /** + * Obtain a [JSRealm] according to the provided [node]; if [node] is `null`, the root [JSRealm] is returned. + * + * @param node the node to obtain the [JSRealm] for; if `null`, the root [JSRealm] is returned + * @return the [JSRealm] for the provided [node], or the root [JSRealm] if [node] is `null` + */ + @JvmStatic @Suppress("unused") fun obtainRealm(node: Node? = null): JSRealm = JSRealm.get(node) + + // Bootstrap a JavaScript realm; if the realm is the root realm, additional setup is performed. + private fun JSRealm.bootstrap(root: Boolean) { + logging.info("Acquired realm (root: $root) / $this") + ElideEsModuleLoader.obtain(this).also { + JSRealmPatcher.installModuleLoader(this, it) + } + } +} diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/intrinsics/ElideIntrinsic.kt b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/intrinsics/ElideIntrinsic.kt index 51b393966..24472aa77 100644 --- a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/intrinsics/ElideIntrinsic.kt +++ b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/intrinsics/ElideIntrinsic.kt @@ -23,6 +23,7 @@ import elide.runtime.gvm.GuestLanguage import elide.runtime.gvm.api.ElideAPI import elide.runtime.gvm.api.Intrinsic import elide.runtime.gvm.internals.intrinsics.js.AbstractJsIntrinsic +import elide.runtime.gvm.internals.js.ElideJavaScriptLanguage import elide.runtime.gvm.js.JsSymbol.JsSymbols.asPublicJsSymbol import elide.runtime.node.process.NodeProcess import elide.runtime.intrinsics.GuestIntrinsic.MutableIntrinsicBindings @@ -72,7 +73,8 @@ public fun installElideBuiltin(name: String, value: Any) { mappedDeferredValue[name] = value } - override fun supports(language: GuestLanguage): Boolean = language.engine == "js" + override fun supports(language: GuestLanguage): Boolean = + language.engine == "js" || language.requestId == ElideJavaScriptLanguage.ID @get:Polyglot override val process: ProcessAPI get() = NodeProcess.obtain() @get:Polyglot override val version: String get() = ELIDE_VERSION_STUBBED diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/js/ElideJavaScriptLanguage.kt b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/js/ElideJavaScriptLanguage.kt new file mode 100644 index 000000000..b3c39c70d --- /dev/null +++ b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/js/ElideJavaScriptLanguage.kt @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2024-2025 Elide Technologies, Inc. + * + * Licensed under the MIT license (the "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://opensource.org/license/mit/ + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under the License. + */ +package elide.runtime.gvm.internals.js + +import com.oracle.truffle.api.CallTarget +import com.oracle.truffle.api.CompilerAsserts +import com.oracle.truffle.api.CompilerDirectives.CompilationFinal +import com.oracle.truffle.api.TruffleLanguage +import com.oracle.truffle.api.TruffleLanguage.ContextPolicy +import com.oracle.truffle.api.TruffleLanguage.Registration +import com.oracle.truffle.api.nodes.ExecutableNode +import com.oracle.truffle.js.lang.JSFileTypeDetector +import com.oracle.truffle.js.lang.JavaScriptLanguage +import com.oracle.truffle.js.runtime.JSRealm +import org.graalvm.polyglot.SandboxPolicy + +// Private engine constants. +private const val ELIDE_JS_LANGUAGE_NAME = "JavaScript" +private const val ELIDE_JS_LANGUAGE_IMPL = "Elide/GraalJs" +private const val ELIDE_JS_VERSION = "r3-es2024-gvm24-1.0.0-alpha14" // @TODO: symbolic version + +// Public engine constants. +public const val ELIDE_JS_LANGUAGE_ID: String = "ejs" +public const val ELIDE_TS_LANGUAGE_ID: String = "ts" +public const val ELIDE_HELP_LINK: String = "https://docs.elide.dev" + +/** + * ## Elide JavaScript + */ +@Registration( + id = ELIDE_JS_LANGUAGE_ID, + name = ELIDE_JS_LANGUAGE_NAME, + implementationName = ELIDE_JS_LANGUAGE_IMPL, + version = ELIDE_JS_VERSION, + dependentLanguages = [JavaScriptLanguage.ID], + defaultMimeType = JavaScriptLanguage.APPLICATION_MIME_TYPE, + website = ELIDE_HELP_LINK, + fileTypeDetectors = [ + //ElideJsFileTypeDetector::class, + JSFileTypeDetector::class, + ], + contextPolicy = ContextPolicy.SHARED, + sandbox = SandboxPolicy.TRUSTED, + characterMimeTypes = [ + TYPESCRIPT_TEXT_MIME_TYPE, + TYPESCRIPT_MIME_TYPE, + TYPESCRIPT_MODULE_MIME_TYPE, + JAVASCRIPT_APPLICATION_MIME_TYPE, + JAVASCRIPT_MODULE_MIME_TYPE, + JAVASCRIPT_TEXT_MIME_TYPE, + JAVASCRIPT_JSON_MIME_TYPE, + ], +) +public class ElideJavaScriptLanguage : TruffleLanguage() { + public companion object { + /** ID to use when requesting Elide JS. */ + public const val ID: String = ELIDE_JS_LANGUAGE_ID + + /** ID to use when requesting Elide TypeScript. */ + public const val TYPESCRIPT: String = ELIDE_TS_LANGUAGE_ID + + private val superCreateContext by lazy { + requireNotNull( + JavaScriptLanguage::class.java.getDeclaredMethod("createContext", Env::class.java), + ) { + "Failed to resolve JavaScriptLanguage::createContext(Env)" + }.also { + it.isAccessible = true + } + } + + private val superParseInline by lazy { + requireNotNull( + JavaScriptLanguage::class.java.getDeclaredMethod("parse", InlineParsingRequest::class.java), + ) { + "Failed to resolve JavaScriptLanguage::parse(InlineParsingRequest)" + }.also { + it.isAccessible = true + } + } + + private val superParse by lazy { + requireNotNull( + JavaScriptLanguage::class.java.getDeclaredMethod("parse", ParsingRequest::class.java), + ) { + "Failed to resolve JavaScriptLanguage::parse(ParsingRequest)" + }.also { + it.isAccessible = true + } + } + } + + // First-seen JavaScript env. + @CompilationFinal private lateinit var rootEnv: Env + + // JavaScript language base. + @CompilationFinal private lateinit var javascript: JavaScriptLanguage + + override fun createContext(currentEnv: Env): JSRealm { + CompilerAsserts.neverPartOfCompilation() + val jsInfo = currentEnv.internalLanguages[JavaScriptLanguage.ID] + currentEnv.initializeLanguage(jsInfo) + val js = JavaScriptLanguage.getCurrentLanguage() + val jsEnv = JavaScriptLanguage.getCurrentEnv() + if (!this::rootEnv.isInitialized) { + rootEnv = currentEnv + javascript = js + } + return superCreateContext(javascript, jsEnv) as JSRealm + } + + override fun parse(request: InlineParsingRequest?): ExecutableNode? { + return superParseInline(javascript, request) as? ExecutableNode + } + + override fun parse(request: ParsingRequest?): CallTarget? { + return superParse(javascript, request) as? CallTarget + } +} diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/js/ElideJsFileTypeDetector.kt b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/js/ElideJsFileTypeDetector.kt new file mode 100644 index 000000000..59d840fbb --- /dev/null +++ b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/js/ElideJsFileTypeDetector.kt @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2024-2025 Elide Technologies, Inc. + * + * Licensed under the MIT license (the "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * https://opensource.org/license/mit/ + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under the License. + */ +package elide.runtime.gvm.internals.js + +import com.oracle.truffle.api.TruffleFile +import com.oracle.truffle.js.lang.JavaScriptLanguage +import java.nio.charset.Charset + +// Mime type/file type constants. +internal const val JAVASCRIPT_APPLICATION_MIME_TYPE = JavaScriptLanguage.APPLICATION_MIME_TYPE +internal const val JAVASCRIPT_MODULE_MIME_TYPE = JavaScriptLanguage.MODULE_MIME_TYPE +internal const val JAVASCRIPT_TEXT_MIME_TYPE = JavaScriptLanguage.TEXT_MIME_TYPE +internal const val JAVASCRIPT_JSON_MIME_TYPE = JavaScriptLanguage.JSON_MIME_TYPE +internal const val TYPESCRIPT_TEXT_MIME_TYPE = "text/typescript" +internal const val TYPESCRIPT_MIME_TYPE = "application/typescript" +internal const val TYPESCRIPT_MODULE_MIME_TYPE = "application/typescript+module" + +// Implements a file type detector for JavaScript and TypeScript file types supported by Elide. +internal class ElideJsFileTypeDetector : TruffleFile.FileTypeDetector { + override fun findEncoding(file: TruffleFile?): Charset { + TODO("Not yet implemented") + } + + override fun findMimeType(file: TruffleFile?): String { + TODO("Not yet implemented") + } +} diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/js/JavaScript.kt b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/js/JavaScript.kt index 63320ad69..e3659c531 100644 --- a/packages/graalvm/src/main/kotlin/elide/runtime/gvm/js/JavaScript.kt +++ b/packages/graalvm/src/main/kotlin/elide/runtime/gvm/js/JavaScript.kt @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Elide Technologies, Inc. + * Copyright (c) 2024-2025 Elide Technologies, Inc. * * Licensed under the MIT license (the "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at @@ -12,6 +12,12 @@ */ package elide.runtime.gvm.js +import com.oracle.truffle.api.strings.TruffleString +import com.oracle.truffle.js.runtime.Strings +import com.oracle.truffle.js.runtime.Symbol +import com.oracle.truffle.js.runtime.objects.JSDynamicObject +import com.oracle.truffle.js.runtime.objects.Null +import com.oracle.truffle.js.runtime.objects.Undefined import io.micronaut.http.HttpRequest import java.io.InputStream import java.io.Reader @@ -50,6 +56,14 @@ import elide.ssr.type.RequestState * applied guest I/O policy. */ public object JavaScript { + /** `Elide` constant. */ + @JvmStatic public val ELIDE: TruffleString = Strings.constant("Elide") + + /** + * [ELIDE] corresponding symbol. + */ + @JvmStatic public val SYMBOL_ELIDE: Symbol = Symbol.createPrivate(ELIDE) + /** * ## JavaScript: Literal from string. * @@ -105,3 +119,17 @@ public object JavaScript { } } } + +/** + * ### JavaScript: Undefined + * + * Returns the singleton instance describing JavaScript's `undefined` value. + */ +public fun undefined(): JSDynamicObject = Undefined.instance + +/** + * ### JavaScript: Null + * + * Returns the singleton instance describing JavaScript's `null` value. + */ +public fun nullvalue(): JSDynamicObject = Null.instance diff --git a/packages/graalvm/src/main/kotlin/elide/runtime/plugins/js/JavaScript.kt b/packages/graalvm/src/main/kotlin/elide/runtime/plugins/js/JavaScript.kt index e21849021..03bfa21a7 100644 --- a/packages/graalvm/src/main/kotlin/elide/runtime/plugins/js/JavaScript.kt +++ b/packages/graalvm/src/main/kotlin/elide/runtime/plugins/js/JavaScript.kt @@ -12,7 +12,6 @@ */ package elide.runtime.plugins.js -import org.graalvm.polyglot.Engine import org.graalvm.polyglot.Source import java.util.concurrent.atomic.AtomicBoolean import elide.runtime.LogLevel.DEBUG @@ -27,6 +26,7 @@ import elide.runtime.core.extensions.disableOptions import elide.runtime.core.extensions.enableOptions import elide.runtime.core.extensions.setOptions import elide.runtime.core.plugin +import elide.runtime.gvm.internals.JavaScriptLang import elide.runtime.plugins.AbstractLanguagePlugin import elide.runtime.plugins.AbstractLanguagePlugin.LanguagePluginManifest import elide.runtime.plugins.env.Environment @@ -71,6 +71,8 @@ import elide.runtime.plugins.js.JavaScriptVersion.* }.build() @Synchronized private fun finalizeContext(context: PolyglotContext) { + // initialize root realm hooks + JavaScriptLang.initialize() config.builtinModulesConfig.finalize() if (EXPERIMENTAL_MODULE_PRELOADING && !modulesInitialized.get() && shouldPreloadModules) { modulesInitialized.compareAndSet(false, true) @@ -195,7 +197,7 @@ import elide.runtime.plugins.js.JavaScriptVersion.* private const val JS_LANGUAGE_ID = "js" private const val JS_PLUGIN_ID = "JavaScript" - private const val EXPERIMENTAL_MODULE_PRELOADING = true + private const val EXPERIMENTAL_MODULE_PRELOADING = false private const val WASI_STD = "wasi_snapshot_preview1" private const val FUNCTION_CONSTRUCTOR_CACHE_SIZE: String = "256" diff --git a/packages/graalvm/src/main/resources/META-INF/elide/embedded/runtime/js/facade.js b/packages/graalvm/src/main/resources/META-INF/elide/embedded/runtime/js/facade.js index cef2830f6..4529fd3f4 100755 --- a/packages/graalvm/src/main/resources/META-INF/elide/embedded/runtime/js/facade.js +++ b/packages/graalvm/src/main/resources/META-INF/elide/embedded/runtime/js/facade.js @@ -1,3 +1,3 @@ -(function(){}).call({}); +(function(){globalThis.window=void 0,globalThis.gc=null}).call({}); // Elide JS Runtime. Copyright (c) 2023, Sam Gammon and the Elide Project Authors. All rights reserved. // Components of this software are licensed separately. See https://github.com/elide-dev/elide for more. diff --git a/packages/graalvm/src/main/resources/META-INF/elide/embedded/runtime/js/polyfills.js b/packages/graalvm/src/main/resources/META-INF/elide/embedded/runtime/js/polyfills.js index 9e73bea51..639556dca 100755 --- a/packages/graalvm/src/main/resources/META-INF/elide/embedded/runtime/js/polyfills.js +++ b/packages/graalvm/src/main/resources/META-INF/elide/embedded/runtime/js/polyfills.js @@ -1 +1 @@ -(()=>{var m=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?Symbol:e=>`Symbol(${e})`;function lt(){}function ln(){if(typeof self!="undefined")return self;if(typeof window!="undefined")return window;if(typeof global!="undefined")return global}var ke=ln();function w(e){return typeof e=="object"&&e!==null||typeof e=="function"}var Vt=lt,dt=Promise,dn=Promise.prototype.then,fn=Promise.resolve.bind(dt),cn=Promise.reject.bind(dt);function S(e){return new dt(e)}function _(e){return fn(e)}function l(e){return cn(e)}function z(e,t,r){return dn.call(e,t,r)}function E(e,t,r){z(z(e,t,r),void 0,Vt)}function ft(e,t){E(e,t)}function ct(e,t){E(e,void 0,t)}function X(e,t,r){return z(e,t,r)}function ge(e){z(e,void 0,Vt)}var Be=(()=>{let e=ke&&ke.queueMicrotask;if(typeof e=="function")return e;let t=_(void 0);return r=>z(t,r)})();function Oe(e,t,r){if(typeof e!="function")throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e,t,r)}function Z(e,t,r){try{return _(Oe(e,t,r))}catch(n){return l(n)}}var Gt=16384,T=class{constructor(){this._cursor=0,this._size=0,this._front={_elements:[],_next:void 0},this._back=this._front,this._cursor=0,this._size=0}get length(){return this._size}push(t){let r=this._back,n=r;r._elements.length===Gt-1&&(n={_elements:[],_next:void 0}),r._elements.push(t),n!==r&&(this._back=n,r._next=n),++this._size}shift(){let t=this._front,r=t,n=this._cursor,a=n+1,o=t._elements,i=o[n];return a===Gt&&(r=t._next,a=0),--this._size,this._cursor=a,t!==r&&(this._front=r),o[n]=void 0,i}forEach(t){let r=this._cursor,n=this._front,a=n._elements;for(;(r!==a.length||n._next!==void 0)&&!(r===a.length&&(n=n._next,a=n._elements,r=0,a.length===0));)t(a[r]),++r}peek(){let t=this._front,r=this._cursor;return t._elements[r]}};function Xt(e,t){e._ownerReadableStream=t,t._reader=e,t._state==="readable"?ht(e):t._state==="closed"?bn(e):Zt(e,t._storedError)}function bt(e,t){let r=e._ownerReadableStream;return k(r,t)}function I(e){e._ownerReadableStream._state==="readable"?mt(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")):hn(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")),e._ownerReadableStream._reader=void 0,e._ownerReadableStream=void 0}function ce(e){return new TypeError("Cannot "+e+" a stream using a released reader")}function ht(e){e._closedPromise=S((t,r)=>{e._closedPromise_resolve=t,e._closedPromise_reject=r})}function Zt(e,t){ht(e),mt(e,t)}function bn(e){ht(e),Jt(e)}function mt(e,t){e._closedPromise_reject!==void 0&&(ge(e._closedPromise),e._closedPromise_reject(t),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}function hn(e,t){Zt(e,t)}function Jt(e){e._closedPromise_resolve!==void 0&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}var Kt=m("[[AbortSteps]]"),xt=m("[[ErrorSteps]]"),_t=m("[[CancelSteps]]"),pt=m("[[PullSteps]]"),er=Number.isFinite||function(e){return typeof e=="number"&&isFinite(e)},mn=Math.trunc||function(e){return e<0?Math.ceil(e):Math.floor(e)};function _n(e){return typeof e=="object"||typeof e=="function"}function F(e,t){if(e!==void 0&&!_n(e))throw new TypeError(`${t} is not an object.`)}function W(e,t){if(typeof e!="function")throw new TypeError(`${t} is not a function.`)}function pn(e){return typeof e=="object"&&e!==null||typeof e=="function"}function tr(e,t){if(!pn(e))throw new TypeError(`${t} is not an object.`)}function D(e,t,r){if(e===void 0)throw new TypeError(`Parameter ${t} is required in '${r}'.`)}function yt(e,t,r){if(e===void 0)throw new TypeError(`${t} is required in '${r}'.`)}function St(e){return Number(e)}function rr(e){return e===0?0:e}function yn(e){return rr(mn(e))}function nr(e,t){let r=0,n=Number.MAX_SAFE_INTEGER,a=Number(e);if(a=rr(a),!er(a))throw new TypeError(`${t} is not a finite number`);if(a=yn(a),an)throw new TypeError(`${t} is outside the accepted range of ${r} to ${n}, inclusive`);return!er(a)||a===0?0:a}function gt(e,t){if(!V(e))throw new TypeError(`${t} is not a ReadableStream.`)}function be(e){return new J(e)}function ar(e,t){e._reader._readRequests.push(t)}function Rt(e,t,r){let a=e._reader._readRequests.shift();r?a._closeSteps():a._chunkSteps(t)}function je(e){return e._reader._readRequests.length}function or(e){let t=e._reader;return!(t===void 0||!$(t))}var J=class{constructor(t){if(D(t,1,"ReadableStreamDefaultReader"),gt(t,"First parameter"),G(t))throw new TypeError("This stream has already been locked for exclusive reading by another reader");Xt(this,t),this._readRequests=new T}get closed(){return $(this)?this._closedPromise:l(ze("closed"))}cancel(t=void 0){return $(this)?this._ownerReadableStream===void 0?l(ce("cancel")):bt(this,t):l(ze("cancel"))}read(){if(!$(this))return l(ze("read"));if(this._ownerReadableStream===void 0)return l(ce("read from"));let t,r,n=S((o,i)=>{t=o,r=i});return Re(this,{_chunkSteps:o=>t({value:o,done:!1}),_closeSteps:()=>t({value:void 0,done:!0}),_errorSteps:o=>r(o)}),n}releaseLock(){if(!$(this))throw ze("releaseLock");if(this._ownerReadableStream!==void 0){if(this._readRequests.length>0)throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");I(this)}}};Object.defineProperties(J.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(J.prototype,m.toStringTag,{value:"ReadableStreamDefaultReader",configurable:!0});function $(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_readRequests")?!1:e instanceof J}function Re(e,t){let r=e._ownerReadableStream;r._disturbed=!0,r._state==="closed"?t._closeSteps():r._state==="errored"?t._errorSteps(r._storedError):r._readableStreamController[pt](t)}function ze(e){return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`)}var ir=Object.getPrototypeOf(Object.getPrototypeOf(async function*(){}).prototype),wt=class{constructor(t,r){this._ongoingPromise=void 0,this._isFinished=!1,this._reader=t,this._preventCancel=r}next(){let t=()=>this._nextSteps();return this._ongoingPromise=this._ongoingPromise?X(this._ongoingPromise,t,t):t(),this._ongoingPromise}return(t){let r=()=>this._returnSteps(t);return this._ongoingPromise?X(this._ongoingPromise,r,r):r()}_nextSteps(){if(this._isFinished)return Promise.resolve({value:void 0,done:!0});let t=this._reader;if(t._ownerReadableStream===void 0)return l(ce("iterate"));let r,n,a=S((i,s)=>{r=i,n=s});return Re(t,{_chunkSteps:i=>{this._ongoingPromise=void 0,Be(()=>r({value:i,done:!1}))},_closeSteps:()=>{this._ongoingPromise=void 0,this._isFinished=!0,I(t),r({value:void 0,done:!0})},_errorSteps:i=>{this._ongoingPromise=void 0,this._isFinished=!0,I(t),n(i)}}),a}_returnSteps(t){if(this._isFinished)return Promise.resolve({value:t,done:!0});this._isFinished=!0;let r=this._reader;if(r._ownerReadableStream===void 0)return l(ce("finish iterating"));if(!this._preventCancel){let n=bt(r,t);return I(r),X(n,()=>({value:t,done:!0}))}return I(r),_({value:t,done:!0})}},sr={next(){return ur(this)?this._asyncIteratorImpl.next():l(lr("next"))},return(e){return ur(this)?this._asyncIteratorImpl.return(e):l(lr("return"))}};ir!==void 0&&Object.setPrototypeOf(sr,ir);function Sn(e,t){let r=be(e),n=new wt(r,t),a=Object.create(sr);return a._asyncIteratorImpl=n,a}function ur(e){if(!w(e)||!Object.prototype.hasOwnProperty.call(e,"_asyncIteratorImpl"))return!1;try{return e._asyncIteratorImpl instanceof wt}catch{return!1}}function lr(e){return new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`)}var dr=Number.isNaN||function(e){return e!==e};function we(e){return e.slice()}function fr(e,t,r,n,a){new Uint8Array(e).set(new Uint8Array(r,n,a),t)}function Da(e){return e}function Ie(e){return!1}function cr(e,t,r){if(e.slice)return e.slice(t,r);let n=r-t,a=new ArrayBuffer(n);return fr(a,0,e,t,n),a}function gn(e){return!(typeof e!="number"||dr(e)||e<0)}function br(e){let t=cr(e.buffer,e.byteOffset,e.byteOffset+e.byteLength);return new Uint8Array(t)}function Ct(e){let t=e._queue.shift();return e._queueTotalSize-=t.size,e._queueTotalSize<0&&(e._queueTotalSize=0),t.value}function Pt(e,t,r){if(!gn(r)||r===1/0)throw new RangeError("Size must be a finite, non-NaN, non-negative number.");e._queue.push({value:t,size:r}),e._queueTotalSize+=r}function Rn(e){return e._queue.peek().value}function M(e){e._queue=new T,e._queueTotalSize=0}var K=class{constructor(){throw new TypeError("Illegal constructor")}get view(){if(!Tt(this))throw qt("view");return this._view}respond(t){if(!Tt(this))throw qt("respond");if(D(t,1,"respond"),t=nr(t,"First parameter"),this._associatedReadableByteStreamController===void 0)throw new TypeError("This BYOB request has been invalidated");Ie(this._view.buffer),Me(this._associatedReadableByteStreamController,t)}respondWithNewView(t){if(!Tt(this))throw qt("respondWithNewView");if(D(t,1,"respondWithNewView"),!ArrayBuffer.isView(t))throw new TypeError("You can only respond with array buffer views");if(this._associatedReadableByteStreamController===void 0)throw new TypeError("This BYOB request has been invalidated");Ie(t.buffer),Ne(this._associatedReadableByteStreamController,t)}};Object.defineProperties(K.prototype,{respond:{enumerable:!0},respondWithNewView:{enumerable:!0},view:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(K.prototype,m.toStringTag,{value:"ReadableStreamBYOBRequest",configurable:!0});var N=class{constructor(){throw new TypeError("Illegal constructor")}get byobRequest(){if(!x(this))throw Pe("byobRequest");return Wt(this)}get desiredSize(){if(!x(this))throw Pe("desiredSize");return Rr(this)}close(){if(!x(this))throw Pe("close");if(this._closeRequested)throw new TypeError("The stream has already been closed; do not close it again!");let t=this._controlledReadableByteStream._state;if(t!=="readable")throw new TypeError(`The stream (in ${t} state) is not in the readable state and cannot be closed`);Ce(this)}enqueue(t){if(!x(this))throw Pe("enqueue");if(D(t,1,"enqueue"),!ArrayBuffer.isView(t))throw new TypeError("chunk must be an array buffer view");if(t.byteLength===0)throw new TypeError("chunk must have non-zero byteLength");if(t.buffer.byteLength===0)throw new TypeError("chunk's buffer must have non-zero byteLength");if(this._closeRequested)throw new TypeError("stream is closed or draining");let r=this._controlledReadableByteStream._state;if(r!=="readable")throw new TypeError(`The stream (in ${r} state) is not in the readable state and cannot be enqueued to`);$e(this,t)}error(t=void 0){if(!x(this))throw Pe("error");q(this,t)}[_t](t){hr(this),M(this);let r=this._cancelAlgorithm(t);return Le(this),r}[pt](t){let r=this._controlledReadableByteStream;if(this._queueTotalSize>0){let a=this._queue.shift();this._queueTotalSize-=a.byteLength,yr(this);let o=new Uint8Array(a.buffer,a.byteOffset,a.byteLength);t._chunkSteps(o);return}let n=this._autoAllocateChunkSize;if(n!==void 0){let a;try{a=new ArrayBuffer(n)}catch(i){t._errorSteps(i);return}let o={buffer:a,bufferByteLength:n,byteOffset:0,byteLength:n,bytesFilled:0,elementSize:1,viewConstructor:Uint8Array,readerType:"default"};this._pendingPullIntos.push(o)}ar(r,t),ee(this)}};Object.defineProperties(N.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},byobRequest:{enumerable:!0},desiredSize:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(N.prototype,m.toStringTag,{value:"ReadableByteStreamController",configurable:!0});function x(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledReadableByteStream")?!1:e instanceof N}function Tt(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_associatedReadableByteStreamController")?!1:e instanceof K}function ee(e){if(!Tn(e))return;if(e._pulling){e._pullAgain=!0;return}e._pulling=!0;let r=e._pullAlgorithm();E(r,()=>{e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,ee(e))},n=>{q(e,n)})}function hr(e){Et(e),e._pendingPullIntos=new T}function vt(e,t){let r=!1;e._state==="closed"&&(r=!0);let n=mr(t);t.readerType==="default"?Rt(e,n,r):Wn(e,n,r)}function mr(e){let t=e.bytesFilled,r=e.elementSize;return new e.viewConstructor(e.buffer,e.byteOffset,t/r)}function Fe(e,t,r,n){e._queue.push({buffer:t,byteOffset:r,byteLength:n}),e._queueTotalSize+=n}function _r(e,t){let r=t.elementSize,n=t.bytesFilled-t.bytesFilled%r,a=Math.min(e._queueTotalSize,t.byteLength-t.bytesFilled),o=t.bytesFilled+a,i=o-o%r,s=a,d=!1;i>n&&(s=i-t.bytesFilled,d=!0);let c=e._queue;for(;s>0;){let b=c.peek(),h=Math.min(s,b.byteLength),y=t.byteOffset+t.bytesFilled;fr(t.buffer,y,b.buffer,b.byteOffset,h),b.byteLength===h?c.shift():(b.byteOffset+=h,b.byteLength-=h),e._queueTotalSize-=h,pr(e,h,t),s-=h}return d}function pr(e,t,r){r.bytesFilled+=t}function yr(e){e._queueTotalSize===0&&e._closeRequested?(Le(e),qe(e._controlledReadableByteStream)):ee(e)}function Et(e){e._byobRequest!==null&&(e._byobRequest._associatedReadableByteStreamController=void 0,e._byobRequest._view=null,e._byobRequest=null)}function Sr(e){for(;e._pendingPullIntos.length>0;){if(e._queueTotalSize===0)return;let t=e._pendingPullIntos.peek();_r(e,t)&&(De(e),vt(e._controlledReadableByteStream,t))}}function wn(e,t,r){let n=e._controlledReadableByteStream,a=1;t.constructor!==DataView&&(a=t.constructor.BYTES_PER_ELEMENT);let o=t.constructor,i=t.buffer,s={buffer:i,bufferByteLength:i.byteLength,byteOffset:t.byteOffset,byteLength:t.byteLength,bytesFilled:0,elementSize:a,viewConstructor:o,readerType:"byob"};if(e._pendingPullIntos.length>0){e._pendingPullIntos.push(s),Pr(n,r);return}if(n._state==="closed"){let d=new o(s.buffer,s.byteOffset,0);r._closeSteps(d);return}if(e._queueTotalSize>0){if(_r(e,s)){let d=mr(s);yr(e),r._chunkSteps(d);return}if(e._closeRequested){let d=new TypeError("Insufficient bytes to fill elements in the given buffer");q(e,d),r._errorSteps(d);return}}e._pendingPullIntos.push(s),Pr(n,r),ee(e)}function Cn(e,t){let r=e._controlledReadableByteStream;if(At(r))for(;Tr(r)>0;){let n=De(e);vt(r,n)}}function Pn(e,t,r){if(pr(e,t,r),r.bytesFilled0){let a=r.byteOffset+r.bytesFilled,o=cr(r.buffer,a-n,a);Fe(e,o,0,o.byteLength)}r.bytesFilled-=n,vt(e._controlledReadableByteStream,r),Sr(e)}function gr(e,t){let r=e._pendingPullIntos.peek();Et(e),e._controlledReadableByteStream._state==="closed"?Cn(e):Pn(e,t,r),ee(e)}function De(e){return e._pendingPullIntos.shift()}function Tn(e){let t=e._controlledReadableByteStream;return t._state!=="readable"||e._closeRequested||!e._started?!1:!!(or(t)&&je(t)>0||At(t)&&Tr(t)>0||Rr(e)>0)}function Le(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0}function Ce(e){let t=e._controlledReadableByteStream;if(!(e._closeRequested||t._state!=="readable")){if(e._queueTotalSize>0){e._closeRequested=!0;return}if(e._pendingPullIntos.length>0&&e._pendingPullIntos.peek().bytesFilled>0){let n=new TypeError("Insufficient bytes to fill elements in the given buffer");throw q(e,n),n}Le(e),qe(t)}}function $e(e,t){let r=e._controlledReadableByteStream;if(e._closeRequested||r._state!=="readable")return;let n=t.buffer,a=t.byteOffset,o=t.byteLength,i=n;if(e._pendingPullIntos.length>0){let s=e._pendingPullIntos.peek();Ie(s.buffer),s.buffer=s.buffer}if(Et(e),or(r))if(je(r)===0)Fe(e,i,a,o);else{e._pendingPullIntos.length>0&&De(e);let s=new Uint8Array(i,a,o);Rt(r,s,!1)}else At(r)?(Fe(e,i,a,o),Sr(e)):Fe(e,i,a,o);ee(e)}function q(e,t){let r=e._controlledReadableByteStream;r._state==="readable"&&(hr(e),M(e),Le(e),Xr(r,t))}function Wt(e){if(e._byobRequest===null&&e._pendingPullIntos.length>0){let t=e._pendingPullIntos.peek(),r=new Uint8Array(t.buffer,t.byteOffset+t.bytesFilled,t.byteLength-t.bytesFilled),n=Object.create(K.prototype);En(n,e,r),e._byobRequest=n}return e._byobRequest}function Rr(e){let t=e._controlledReadableByteStream._state;return t==="errored"?null:t==="closed"?0:e._strategyHWM-e._queueTotalSize}function Me(e,t){let r=e._pendingPullIntos.peek();if(e._controlledReadableByteStream._state==="closed"){if(t!==0)throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream")}else{if(t===0)throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");if(r.bytesFilled+t>r.byteLength)throw new RangeError("bytesWritten out of range")}r.buffer=r.buffer,gr(e,t)}function Ne(e,t){let r=e._pendingPullIntos.peek();if(e._controlledReadableByteStream._state==="closed"){if(t.byteLength!==0)throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream")}else if(t.byteLength===0)throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");if(r.byteOffset+r.bytesFilled!==t.byteOffset)throw new RangeError("The region specified by view does not match byobRequest");if(r.bufferByteLength!==t.buffer.byteLength)throw new RangeError("The buffer of view has different capacity than byobRequest");if(r.bytesFilled+t.byteLength>r.byteLength)throw new RangeError("The region specified by view is larger than byobRequest");let a=t.byteLength;r.buffer=t.buffer,gr(e,a)}function wr(e,t,r,n,a,o,i){t._controlledReadableByteStream=e,t._pullAgain=!1,t._pulling=!1,t._byobRequest=null,t._queue=t._queueTotalSize=void 0,M(t),t._closeRequested=!1,t._started=!1,t._strategyHWM=o,t._pullAlgorithm=n,t._cancelAlgorithm=a,t._autoAllocateChunkSize=i,t._pendingPullIntos=new T,e._readableStreamController=t;let s=r();E(_(s),()=>{t._started=!0,ee(t)},d=>{q(t,d)})}function vn(e,t,r){let n=Object.create(N.prototype),a=()=>{},o=()=>_(void 0),i=()=>_(void 0);t.start!==void 0&&(a=()=>t.start(n)),t.pull!==void 0&&(o=()=>t.pull(n)),t.cancel!==void 0&&(i=d=>t.cancel(d));let s=t.autoAllocateChunkSize;if(s===0)throw new TypeError("autoAllocateChunkSize must be greater than 0");wr(e,n,a,o,i,r,s)}function En(e,t,r){e._associatedReadableByteStreamController=t,e._view=r}function qt(e){return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`)}function Pe(e){return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`)}function Cr(e){return new te(e)}function Pr(e,t){e._reader._readIntoRequests.push(t)}function Wn(e,t,r){let a=e._reader._readIntoRequests.shift();r?a._closeSteps(t):a._chunkSteps(t)}function Tr(e){return e._reader._readIntoRequests.length}function At(e){let t=e._reader;return!(t===void 0||!re(t))}var te=class{constructor(t){if(D(t,1,"ReadableStreamBYOBReader"),gt(t,"First parameter"),G(t))throw new TypeError("This stream has already been locked for exclusive reading by another reader");if(!x(t._readableStreamController))throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");Xt(this,t),this._readIntoRequests=new T}get closed(){return re(this)?this._closedPromise:l(Qe("closed"))}cancel(t=void 0){return re(this)?this._ownerReadableStream===void 0?l(ce("cancel")):bt(this,t):l(Qe("cancel"))}read(t){if(!re(this))return l(Qe("read"));if(!ArrayBuffer.isView(t))return l(new TypeError("view must be an array buffer view"));if(t.byteLength===0)return l(new TypeError("view must have non-zero byteLength"));if(t.buffer.byteLength===0)return l(new TypeError("view's buffer must have non-zero byteLength"));if(Ie(t.buffer),this._ownerReadableStream===void 0)return l(ce("read from"));let r,n,a=S((i,s)=>{r=i,n=s});return vr(this,t,{_chunkSteps:i=>r({value:i,done:!1}),_closeSteps:i=>r({value:i,done:!0}),_errorSteps:i=>n(i)}),a}releaseLock(){if(!re(this))throw Qe("releaseLock");if(this._ownerReadableStream!==void 0){if(this._readIntoRequests.length>0)throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");I(this)}}};Object.defineProperties(te.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(te.prototype,m.toStringTag,{value:"ReadableStreamBYOBReader",configurable:!0});function re(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_readIntoRequests")?!1:e instanceof te}function vr(e,t,r){let n=e._ownerReadableStream;n._disturbed=!0,n._state==="errored"?r._errorSteps(n._storedError):wn(n._readableStreamController,t,r)}function Qe(e){return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`)}function Te(e,t){let{highWaterMark:r}=e;if(r===void 0)return t;if(dr(r)||r<0)throw new RangeError("Invalid highWaterMark");return r}function Ue(e){let{size:t}=e;return t||(()=>1)}function He(e,t){F(e,t);let r=e==null?void 0:e.highWaterMark,n=e==null?void 0:e.size;return{highWaterMark:r===void 0?void 0:St(r),size:n===void 0?void 0:qn(n,`${t} has member 'size' that`)}}function qn(e,t){return W(e,t),r=>St(e(r))}function An(e,t){F(e,t);let r=e==null?void 0:e.abort,n=e==null?void 0:e.close,a=e==null?void 0:e.start,o=e==null?void 0:e.type,i=e==null?void 0:e.write;return{abort:r===void 0?void 0:kn(r,e,`${t} has member 'abort' that`),close:n===void 0?void 0:Bn(n,e,`${t} has member 'close' that`),start:a===void 0?void 0:On(a,e,`${t} has member 'start' that`),write:i===void 0?void 0:jn(i,e,`${t} has member 'write' that`),type:o}}function kn(e,t,r){return W(e,r),n=>Z(e,t,[n])}function Bn(e,t,r){return W(e,r),()=>Z(e,t,[])}function On(e,t,r){return W(e,r),n=>Oe(e,t,[n])}function jn(e,t,r){return W(e,r),(n,a)=>Z(e,t,[n,a])}function Er(e,t){if(!he(e))throw new TypeError(`${t} is not a WritableStream.`)}function zn(e){if(typeof e!="object"||e===null)return!1;try{return typeof e.aborted=="boolean"}catch{return!1}}var In=typeof AbortController=="function";function Fn(){if(In)return new AbortController}var Q=class{constructor(t={},r={}){t===void 0?t=null:tr(t,"First parameter");let n=He(r,"Second parameter"),a=An(t,"First parameter");if(qr(this),a.type!==void 0)throw new RangeError("Invalid type is specified");let i=Ue(n),s=Te(n,1);Jn(this,a,s,i)}get locked(){if(!he(this))throw Ze("locked");return me(this)}abort(t=void 0){return he(this)?me(this)?l(new TypeError("Cannot abort a stream that already has a writer")):Ye(this,t):l(Ze("abort"))}close(){return he(this)?me(this)?l(new TypeError("Cannot close a stream that already has a writer")):B(this)?l(new TypeError("Cannot close an already-closing stream")):Ar(this):l(Ze("close"))}getWriter(){if(!he(this))throw Ze("getWriter");return Wr(this)}};Object.defineProperties(Q.prototype,{abort:{enumerable:!0},close:{enumerable:!0},getWriter:{enumerable:!0},locked:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(Q.prototype,m.toStringTag,{value:"WritableStream",configurable:!0});function Wr(e){return new ne(e)}function Dn(e,t,r,n,a=1,o=()=>1){let i=Object.create(Q.prototype);qr(i);let s=Object.create(U.prototype);return Ir(i,s,e,t,r,n,a,o),i}function qr(e){e._state="writable",e._storedError=void 0,e._writer=void 0,e._writableStreamController=void 0,e._writeRequests=new T,e._inFlightWriteRequest=void 0,e._closeRequest=void 0,e._inFlightCloseRequest=void 0,e._pendingAbortRequest=void 0,e._backpressure=!1}function he(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_writableStreamController")?!1:e instanceof Q}function me(e){return e._writer!==void 0}function Ye(e,t){var r;if(e._state==="closed"||e._state==="errored")return _(void 0);e._writableStreamController._abortReason=t,(r=e._writableStreamController._abortController)===null||r===void 0||r.abort();let n=e._state;if(n==="closed"||n==="errored")return _(void 0);if(e._pendingAbortRequest!==void 0)return e._pendingAbortRequest._promise;let a=!1;n==="erroring"&&(a=!0,t=void 0);let o=S((i,s)=>{e._pendingAbortRequest={_promise:void 0,_resolve:i,_reject:s,_reason:t,_wasAlreadyErroring:a}});return e._pendingAbortRequest._promise=o,a||Bt(e,t),o}function Ar(e){let t=e._state;if(t==="closed"||t==="errored")return l(new TypeError(`The stream (in ${t} state) is not in the writable state and cannot be closed`));let r=S((a,o)=>{let i={_resolve:a,_reject:o};e._closeRequest=i}),n=e._writer;return n!==void 0&&e._backpressure&&t==="writable"&&Mt(n),Kn(e._writableStreamController),r}function Ln(e){return S((r,n)=>{let a={_resolve:r,_reject:n};e._writeRequests.push(a)})}function kt(e,t){if(e._state==="writable"){Bt(e,t);return}Ot(e)}function Bt(e,t){let r=e._writableStreamController;e._state="erroring",e._storedError=t;let n=e._writer;n!==void 0&&Br(n,t),!Un(e)&&r._started&&Ot(e)}function Ot(e){e._state="errored",e._writableStreamController[xt]();let t=e._storedError;if(e._writeRequests.forEach(a=>{a._reject(t)}),e._writeRequests=new T,e._pendingAbortRequest===void 0){Ve(e);return}let r=e._pendingAbortRequest;if(e._pendingAbortRequest=void 0,r._wasAlreadyErroring){r._reject(t),Ve(e);return}let n=e._writableStreamController[Kt](r._reason);E(n,()=>{r._resolve(),Ve(e)},a=>{r._reject(a),Ve(e)})}function $n(e){e._inFlightWriteRequest._resolve(void 0),e._inFlightWriteRequest=void 0}function Mn(e,t){e._inFlightWriteRequest._reject(t),e._inFlightWriteRequest=void 0,kt(e,t)}function Nn(e){e._inFlightCloseRequest._resolve(void 0),e._inFlightCloseRequest=void 0,e._state==="erroring"&&(e._storedError=void 0,e._pendingAbortRequest!==void 0&&(e._pendingAbortRequest._resolve(),e._pendingAbortRequest=void 0)),e._state="closed";let r=e._writer;r!==void 0&&$r(r)}function Qn(e,t){e._inFlightCloseRequest._reject(t),e._inFlightCloseRequest=void 0,e._pendingAbortRequest!==void 0&&(e._pendingAbortRequest._reject(t),e._pendingAbortRequest=void 0),kt(e,t)}function B(e){return!(e._closeRequest===void 0&&e._inFlightCloseRequest===void 0)}function Un(e){return!(e._inFlightWriteRequest===void 0&&e._inFlightCloseRequest===void 0)}function Hn(e){e._inFlightCloseRequest=e._closeRequest,e._closeRequest=void 0}function Yn(e){e._inFlightWriteRequest=e._writeRequests.shift()}function Ve(e){e._closeRequest!==void 0&&(e._closeRequest._reject(e._storedError),e._closeRequest=void 0);let t=e._writer;t!==void 0&&Lt(t,e._storedError)}function jt(e,t){let r=e._writer;r!==void 0&&t!==e._backpressure&&(t?oa(r):Mt(r)),e._backpressure=t}var ne=class{constructor(t){if(D(t,1,"WritableStreamDefaultWriter"),Er(t,"First parameter"),me(t))throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream=t,t._writer=this;let r=t._state;if(r==="writable")!B(t)&&t._backpressure?Ke(this):Mr(this),Je(this);else if(r==="erroring")$t(this,t._storedError),Je(this);else if(r==="closed")Mr(this),na(this);else{let n=t._storedError;$t(this,n),Lr(this,n)}}get closed(){return ae(this)?this._closedPromise:l(oe("closed"))}get desiredSize(){if(!ae(this))throw oe("desiredSize");if(this._ownerWritableStream===void 0)throw ve("desiredSize");return Zn(this)}get ready(){return ae(this)?this._readyPromise:l(oe("ready"))}abort(t=void 0){return ae(this)?this._ownerWritableStream===void 0?l(ve("abort")):Vn(this,t):l(oe("abort"))}close(){if(!ae(this))return l(oe("close"));let t=this._ownerWritableStream;return t===void 0?l(ve("close")):B(t)?l(new TypeError("Cannot close an already-closing stream")):kr(this)}releaseLock(){if(!ae(this))throw oe("releaseLock");this._ownerWritableStream!==void 0&&Or(this)}write(t=void 0){return ae(this)?this._ownerWritableStream===void 0?l(ve("write to")):jr(this,t):l(oe("write"))}};Object.defineProperties(ne.prototype,{abort:{enumerable:!0},close:{enumerable:!0},releaseLock:{enumerable:!0},write:{enumerable:!0},closed:{enumerable:!0},desiredSize:{enumerable:!0},ready:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(ne.prototype,m.toStringTag,{value:"WritableStreamDefaultWriter",configurable:!0});function ae(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_ownerWritableStream")?!1:e instanceof ne}function Vn(e,t){let r=e._ownerWritableStream;return Ye(r,t)}function kr(e){let t=e._ownerWritableStream;return Ar(t)}function Gn(e){let t=e._ownerWritableStream,r=t._state;return B(t)||r==="closed"?_(void 0):r==="errored"?l(t._storedError):kr(e)}function Xn(e,t){e._closedPromiseState==="pending"?Lt(e,t):aa(e,t)}function Br(e,t){e._readyPromiseState==="pending"?Nr(e,t):ia(e,t)}function Zn(e){let t=e._ownerWritableStream,r=t._state;return r==="errored"||r==="erroring"?null:r==="closed"?0:Fr(t._writableStreamController)}function Or(e){let t=e._ownerWritableStream,r=new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");Br(e,r),Xn(e,r),t._writer=void 0,e._ownerWritableStream=void 0}function jr(e,t){let r=e._ownerWritableStream,n=r._writableStreamController,a=xn(n,t);if(r!==e._ownerWritableStream)return l(ve("write to"));let o=r._state;if(o==="errored")return l(r._storedError);if(B(r)||o==="closed")return l(new TypeError("The stream is closing or closed and cannot be written to"));if(o==="erroring")return l(r._storedError);let i=Ln(r);return ea(n,t,a),i}var zr={},U=class{constructor(){throw new TypeError("Illegal constructor")}get abortReason(){if(!zt(this))throw Dt("abortReason");return this._abortReason}get signal(){if(!zt(this))throw Dt("signal");if(this._abortController===void 0)throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");return this._abortController.signal}error(t=void 0){if(!zt(this))throw Dt("error");this._controlledWritableStream._state==="writable"&&Dr(this,t)}[Kt](t){let r=this._abortAlgorithm(t);return Ge(this),r}[xt](){M(this)}};Object.defineProperties(U.prototype,{abortReason:{enumerable:!0},signal:{enumerable:!0},error:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(U.prototype,m.toStringTag,{value:"WritableStreamDefaultController",configurable:!0});function zt(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledWritableStream")?!1:e instanceof U}function Ir(e,t,r,n,a,o,i,s){t._controlledWritableStream=e,e._writableStreamController=t,t._queue=void 0,t._queueTotalSize=void 0,M(t),t._abortReason=void 0,t._abortController=Fn(),t._started=!1,t._strategySizeAlgorithm=s,t._strategyHWM=i,t._writeAlgorithm=n,t._closeAlgorithm=a,t._abortAlgorithm=o;let d=Ft(t);jt(e,d);let c=r(),b=_(c);E(b,()=>{t._started=!0,Xe(t)},h=>{t._started=!0,kt(e,h)})}function Jn(e,t,r,n){let a=Object.create(U.prototype),o=()=>{},i=()=>_(void 0),s=()=>_(void 0),d=()=>_(void 0);t.start!==void 0&&(o=()=>t.start(a)),t.write!==void 0&&(i=c=>t.write(c,a)),t.close!==void 0&&(s=()=>t.close()),t.abort!==void 0&&(d=c=>t.abort(c)),Ir(e,a,o,i,s,d,r,n)}function Ge(e){e._writeAlgorithm=void 0,e._closeAlgorithm=void 0,e._abortAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function Kn(e){Pt(e,zr,0),Xe(e)}function xn(e,t){try{return e._strategySizeAlgorithm(t)}catch(r){return It(e,r),1}}function Fr(e){return e._strategyHWM-e._queueTotalSize}function ea(e,t,r){try{Pt(e,t,r)}catch(a){It(e,a);return}let n=e._controlledWritableStream;if(!B(n)&&n._state==="writable"){let a=Ft(e);jt(n,a)}Xe(e)}function Xe(e){let t=e._controlledWritableStream;if(!e._started||t._inFlightWriteRequest!==void 0)return;if(t._state==="erroring"){Ot(t);return}if(e._queue.length===0)return;let n=Rn(e);n===zr?ta(e):ra(e,n)}function It(e,t){e._controlledWritableStream._state==="writable"&&Dr(e,t)}function ta(e){let t=e._controlledWritableStream;Hn(t),Ct(e);let r=e._closeAlgorithm();Ge(e),E(r,()=>{Nn(t)},n=>{Qn(t,n)})}function ra(e,t){let r=e._controlledWritableStream;Yn(r);let n=e._writeAlgorithm(t);E(n,()=>{$n(r);let a=r._state;if(Ct(e),!B(r)&&a==="writable"){let o=Ft(e);jt(r,o)}Xe(e)},a=>{r._state==="writable"&&Ge(e),Mn(r,a)})}function Ft(e){return Fr(e)<=0}function Dr(e,t){let r=e._controlledWritableStream;Ge(e),Bt(r,t)}function Ze(e){return new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`)}function Dt(e){return new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`)}function oe(e){return new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`)}function ve(e){return new TypeError("Cannot "+e+" a stream using a released writer")}function Je(e){e._closedPromise=S((t,r)=>{e._closedPromise_resolve=t,e._closedPromise_reject=r,e._closedPromiseState="pending"})}function Lr(e,t){Je(e),Lt(e,t)}function na(e){Je(e),$r(e)}function Lt(e,t){e._closedPromise_reject!==void 0&&(ge(e._closedPromise),e._closedPromise_reject(t),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="rejected")}function aa(e,t){Lr(e,t)}function $r(e){e._closedPromise_resolve!==void 0&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="resolved")}function Ke(e){e._readyPromise=S((t,r)=>{e._readyPromise_resolve=t,e._readyPromise_reject=r}),e._readyPromiseState="pending"}function $t(e,t){Ke(e),Nr(e,t)}function Mr(e){Ke(e),Mt(e)}function Nr(e,t){e._readyPromise_reject!==void 0&&(ge(e._readyPromise),e._readyPromise_reject(t),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="rejected")}function oa(e){Ke(e)}function ia(e,t){$t(e,t)}function Mt(e){e._readyPromise_resolve!==void 0&&(e._readyPromise_resolve(void 0),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="fulfilled")}var Qr=typeof DOMException!="undefined"?DOMException:void 0;function sa(e){if(!(typeof e=="function"||typeof e=="object"))return!1;try{return new e,!0}catch{return!1}}function ua(){let e=function(r,n){this.message=r||"",this.name=n||"Error",Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)};return e.prototype=Object.create(Error.prototype),Object.defineProperty(e.prototype,"constructor",{value:e,writable:!0,configurable:!0}),e}var la=sa(Qr)?Qr:ua();function Ur(e,t,r,n,a,o){let i=be(e),s=Wr(t);e._disturbed=!0;let d=!1,c=_(void 0);return S((b,h)=>{let y;if(o!==void 0){if(y=()=>{let u=new la("Aborted","AbortError"),f=[];n||f.push(()=>t._state==="writable"?Ye(t,u):_(void 0)),a||f.push(()=>e._state==="readable"?k(e,u):_(void 0)),R(()=>Promise.all(f.map(p=>p())),!0,u)},o.aborted){y();return}o.addEventListener("abort",y)}function v(){return S((u,f)=>{function p(C){C?u():z(ue(),p,f)}p(!1)})}function ue(){return d?_(!0):z(s._readyPromise,()=>S((u,f)=>{Re(i,{_chunkSteps:p=>{c=z(jr(s,p),void 0,lt),u(!1)},_closeSteps:()=>u(!0),_errorSteps:f})}))}if(O(e,i._closedPromise,u=>{n?P(!0,u):R(()=>Ye(t,u),!0,u)}),O(t,s._closedPromise,u=>{a?P(!0,u):R(()=>k(e,u),!0,u)}),g(e,i._closedPromise,()=>{r?P():R(()=>Gn(s))}),B(t)||t._state==="closed"){let u=new TypeError("the destination writable stream closed before all data could be piped to it");a?P(!0,u):R(()=>k(e,u),!0,u)}ge(v());function L(){let u=c;return z(c,()=>u!==c?L():void 0)}function O(u,f,p){u._state==="errored"?p(u._storedError):ct(f,p)}function g(u,f,p){u._state==="closed"?p():ft(f,p)}function R(u,f,p){if(d)return;d=!0,t._state==="writable"&&!B(t)?ft(L(),C):C();function C(){E(u(),()=>j(f,p),le=>j(!0,le))}}function P(u,f){d||(d=!0,t._state==="writable"&&!B(t)?ft(L(),()=>j(u,f)):j(u,f))}function j(u,f){Or(s),I(i),o!==void 0&&o.removeEventListener("abort",y),u?h(f):b(void 0)}})}var H=class{constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!xe(this))throw rt("desiredSize");return Nt(this)}close(){if(!xe(this))throw rt("close");if(!_e(this))throw new TypeError("The stream is not in a state that permits close");We(this)}enqueue(t=void 0){if(!xe(this))throw rt("enqueue");if(!_e(this))throw new TypeError("The stream is not in a state that permits enqueue");return tt(this,t)}error(t=void 0){if(!xe(this))throw rt("error");Y(this,t)}[_t](t){M(this);let r=this._cancelAlgorithm(t);return et(this),r}[pt](t){let r=this._controlledReadableStream;if(this._queue.length>0){let n=Ct(this);this._closeRequested&&this._queue.length===0?(et(this),qe(r)):Ee(this),t._chunkSteps(n)}else ar(r,t),Ee(this)}};Object.defineProperties(H.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},desiredSize:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(H.prototype,m.toStringTag,{value:"ReadableStreamDefaultController",configurable:!0});function xe(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledReadableStream")?!1:e instanceof H}function Ee(e){if(!Hr(e))return;if(e._pulling){e._pullAgain=!0;return}e._pulling=!0;let r=e._pullAlgorithm();E(r,()=>{e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,Ee(e))},n=>{Y(e,n)})}function Hr(e){let t=e._controlledReadableStream;return!_e(e)||!e._started?!1:!!(G(t)&&je(t)>0||Nt(e)>0)}function et(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function We(e){if(!_e(e))return;let t=e._controlledReadableStream;e._closeRequested=!0,e._queue.length===0&&(et(e),qe(t))}function tt(e,t){if(!_e(e))return;let r=e._controlledReadableStream;if(G(r)&&je(r)>0)Rt(r,t,!1);else{let n;try{n=e._strategySizeAlgorithm(t)}catch(a){throw Y(e,a),a}try{Pt(e,t,n)}catch(a){throw Y(e,a),a}}Ee(e)}function Y(e,t){let r=e._controlledReadableStream;r._state==="readable"&&(M(e),et(e),Xr(r,t))}function Nt(e){let t=e._controlledReadableStream._state;return t==="errored"?null:t==="closed"?0:e._strategyHWM-e._queueTotalSize}function da(e){return!Hr(e)}function _e(e){let t=e._controlledReadableStream._state;return!e._closeRequested&&t==="readable"}function Yr(e,t,r,n,a,o,i){t._controlledReadableStream=e,t._queue=void 0,t._queueTotalSize=void 0,M(t),t._started=!1,t._closeRequested=!1,t._pullAgain=!1,t._pulling=!1,t._strategySizeAlgorithm=i,t._strategyHWM=o,t._pullAlgorithm=n,t._cancelAlgorithm=a,e._readableStreamController=t;let s=r();E(_(s),()=>{t._started=!0,Ee(t)},d=>{Y(t,d)})}function fa(e,t,r,n){let a=Object.create(H.prototype),o=()=>{},i=()=>_(void 0),s=()=>_(void 0);t.start!==void 0&&(o=()=>t.start(a)),t.pull!==void 0&&(i=()=>t.pull(a)),t.cancel!==void 0&&(s=d=>t.cancel(d)),Yr(e,a,o,i,s,r,n)}function rt(e){return new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`)}function ca(e,t){return x(e._readableStreamController)?ha(e):ba(e)}function ba(e,t){let r=be(e),n=!1,a=!1,o=!1,i=!1,s,d,c,b,h,y=S(g=>{h=g});function v(){return n?(a=!0,_(void 0)):(n=!0,Re(r,{_chunkSteps:R=>{Be(()=>{a=!1;let P=R,j=R;o||tt(c._readableStreamController,P),i||tt(b._readableStreamController,j),n=!1,a&&v()})},_closeSteps:()=>{n=!1,o||We(c._readableStreamController),i||We(b._readableStreamController),(!o||!i)&&h(void 0)},_errorSteps:()=>{n=!1}}),_(void 0))}function ue(g){if(o=!0,s=g,i){let R=we([s,d]),P=k(e,R);h(P)}return y}function L(g){if(i=!0,d=g,o){let R=we([s,d]),P=k(e,R);h(P)}return y}function O(){}return c=Qt(O,v,ue),b=Qt(O,v,L),ct(r._closedPromise,g=>{Y(c._readableStreamController,g),Y(b._readableStreamController,g),(!o||!i)&&h(void 0)}),[c,b]}function ha(e){let t=be(e),r=!1,n=!1,a=!1,o=!1,i=!1,s,d,c,b,h,y=S(u=>{h=u});function v(u){ct(u._closedPromise,f=>{u===t&&(q(c._readableStreamController,f),q(b._readableStreamController,f),(!o||!i)&&h(void 0))})}function ue(){re(t)&&(I(t),t=be(e),v(t)),Re(t,{_chunkSteps:f=>{Be(()=>{n=!1,a=!1;let p=f,C=f;if(!o&&!i)try{C=br(f)}catch(le){q(c._readableStreamController,le),q(b._readableStreamController,le),h(k(e,le));return}o||$e(c._readableStreamController,p),i||$e(b._readableStreamController,C),r=!1,n?O():a&&g()})},_closeSteps:()=>{r=!1,o||Ce(c._readableStreamController),i||Ce(b._readableStreamController),c._readableStreamController._pendingPullIntos.length>0&&Me(c._readableStreamController,0),b._readableStreamController._pendingPullIntos.length>0&&Me(b._readableStreamController,0),(!o||!i)&&h(void 0)},_errorSteps:()=>{r=!1}})}function L(u,f){$(t)&&(I(t),t=Cr(e),v(t));let p=f?b:c,C=f?c:b;vr(t,u,{_chunkSteps:de=>{Be(()=>{n=!1,a=!1;let fe=f?i:o;if(f?o:i)fe||Ne(p._readableStreamController,de);else{let Yt;try{Yt=br(de)}catch(ut){q(p._readableStreamController,ut),q(C._readableStreamController,ut),h(k(e,ut));return}fe||Ne(p._readableStreamController,de),$e(C._readableStreamController,Yt)}r=!1,n?O():a&&g()})},_closeSteps:de=>{r=!1;let fe=f?i:o,Ae=f?o:i;fe||Ce(p._readableStreamController),Ae||Ce(C._readableStreamController),de!==void 0&&(fe||Ne(p._readableStreamController,de),!Ae&&C._readableStreamController._pendingPullIntos.length>0&&Me(C._readableStreamController,0)),(!fe||!Ae)&&h(void 0)},_errorSteps:()=>{r=!1}})}function O(){if(r)return n=!0,_(void 0);r=!0;let u=Wt(c._readableStreamController);return u===null?ue():L(u._view,!1),_(void 0)}function g(){if(r)return a=!0,_(void 0);r=!0;let u=Wt(b._readableStreamController);return u===null?ue():L(u._view,!0),_(void 0)}function R(u){if(o=!0,s=u,i){let f=we([s,d]),p=k(e,f);h(p)}return y}function P(u){if(i=!0,d=u,o){let f=we([s,d]),p=k(e,f);h(p)}return y}function j(){}return c=Gr(j,O,R),b=Gr(j,g,P),v(t),[c,b]}function ma(e,t){F(e,t);let r=e,n=r==null?void 0:r.autoAllocateChunkSize,a=r==null?void 0:r.cancel,o=r==null?void 0:r.pull,i=r==null?void 0:r.start,s=r==null?void 0:r.type;return{autoAllocateChunkSize:n===void 0?void 0:nr(n,`${t} has member 'autoAllocateChunkSize' that`),cancel:a===void 0?void 0:_a(a,r,`${t} has member 'cancel' that`),pull:o===void 0?void 0:pa(o,r,`${t} has member 'pull' that`),start:i===void 0?void 0:ya(i,r,`${t} has member 'start' that`),type:s===void 0?void 0:Sa(s,`${t} has member 'type' that`)}}function _a(e,t,r){return W(e,r),n=>Z(e,t,[n])}function pa(e,t,r){return W(e,r),n=>Z(e,t,[n])}function ya(e,t,r){return W(e,r),n=>Oe(e,t,[n])}function Sa(e,t){if(e=`${e}`,e!=="bytes")throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamType`);return e}function ga(e,t){F(e,t);let r=e==null?void 0:e.mode;return{mode:r===void 0?void 0:Ra(r,`${t} has member 'mode' that`)}}function Ra(e,t){if(e=`${e}`,e!=="byob")throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);return e}function wa(e,t){F(e,t);let r=e==null?void 0:e.preventCancel;return{preventCancel:Boolean(r)}}function Vr(e,t){F(e,t);let r=e==null?void 0:e.preventAbort,n=e==null?void 0:e.preventCancel,a=e==null?void 0:e.preventClose,o=e==null?void 0:e.signal;return o!==void 0&&Ca(o,`${t} has member 'signal' that`),{preventAbort:Boolean(r),preventCancel:Boolean(n),preventClose:Boolean(a),signal:o}}function Ca(e,t){if(!zn(e))throw new TypeError(`${t} is not an AbortSignal.`)}function Pa(e,t){F(e,t);let r=e==null?void 0:e.readable;yt(r,"readable","ReadableWritablePair"),gt(r,`${t} has member 'readable' that`);let n=e==null?void 0:e.writable;return yt(n,"writable","ReadableWritablePair"),Er(n,`${t} has member 'writable' that`),{readable:r,writable:n}}var A=class{constructor(t={},r={}){t===void 0?t=null:tr(t,"First parameter");let n=He(r,"Second parameter"),a=ma(t,"First parameter");if(Ut(this),a.type==="bytes"){if(n.size!==void 0)throw new RangeError("The strategy for a byte stream cannot have a size function");let o=Te(n,0);vn(this,a,o)}else{let o=Ue(n),i=Te(n,1);fa(this,a,i,o)}}get locked(){if(!V(this))throw ie("locked");return G(this)}cancel(t=void 0){return V(this)?G(this)?l(new TypeError("Cannot cancel a stream that already has a reader")):k(this,t):l(ie("cancel"))}getReader(t=void 0){if(!V(this))throw ie("getReader");return ga(t,"First parameter").mode===void 0?be(this):Cr(this)}pipeThrough(t,r={}){if(!V(this))throw ie("pipeThrough");D(t,1,"pipeThrough");let n=Pa(t,"First parameter"),a=Vr(r,"Second parameter");if(G(this))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if(me(n.writable))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");let o=Ur(this,n.writable,a.preventClose,a.preventAbort,a.preventCancel,a.signal);return ge(o),n.readable}pipeTo(t,r={}){if(!V(this))return l(ie("pipeTo"));if(t===void 0)return l("Parameter 1 is required in 'pipeTo'.");if(!he(t))return l(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));let n;try{n=Vr(r,"Second parameter")}catch(a){return l(a)}return G(this)?l(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")):me(t)?l(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")):Ur(this,t,n.preventClose,n.preventAbort,n.preventCancel,n.signal)}tee(){if(!V(this))throw ie("tee");let t=ca(this);return we(t)}values(t=void 0){if(!V(this))throw ie("values");let r=wa(t,"First parameter");return Sn(this,r.preventCancel)}};Object.defineProperties(A.prototype,{cancel:{enumerable:!0},getReader:{enumerable:!0},pipeThrough:{enumerable:!0},pipeTo:{enumerable:!0},tee:{enumerable:!0},values:{enumerable:!0},locked:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(A.prototype,m.toStringTag,{value:"ReadableStream",configurable:!0}),typeof m.asyncIterator=="symbol"&&Object.defineProperty(A.prototype,m.asyncIterator,{value:A.prototype.values,writable:!0,configurable:!0});function Qt(e,t,r,n=1,a=()=>1){let o=Object.create(A.prototype);Ut(o);let i=Object.create(H.prototype);return Yr(o,i,e,t,r,n,a),o}function Gr(e,t,r){let n=Object.create(A.prototype);Ut(n);let a=Object.create(N.prototype);return wr(n,a,e,t,r,0,void 0),n}function Ut(e){e._state="readable",e._reader=void 0,e._storedError=void 0,e._disturbed=!1}function V(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_readableStreamController")?!1:e instanceof A}function G(e){return e._reader!==void 0}function k(e,t){if(e._disturbed=!0,e._state==="closed")return _(void 0);if(e._state==="errored")return l(e._storedError);qe(e);let r=e._reader;r!==void 0&&re(r)&&(r._readIntoRequests.forEach(a=>{a._closeSteps(void 0)}),r._readIntoRequests=new T);let n=e._readableStreamController[_t](t);return X(n,lt)}function qe(e){e._state="closed";let t=e._reader;t!==void 0&&(Jt(t),$(t)&&(t._readRequests.forEach(r=>{r._closeSteps()}),t._readRequests=new T))}function Xr(e,t){e._state="errored",e._storedError=t;let r=e._reader;r!==void 0&&(mt(r,t),$(r)?(r._readRequests.forEach(n=>{n._errorSteps(t)}),r._readRequests=new T):(r._readIntoRequests.forEach(n=>{n._errorSteps(t)}),r._readIntoRequests=new T))}function ie(e){return new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`)}function Zr(e,t){F(e,t);let r=e==null?void 0:e.highWaterMark;return yt(r,"highWaterMark","QueuingStrategyInit"),{highWaterMark:St(r)}}var Jr=e=>e.byteLength;try{Object.defineProperty(Jr,"name",{value:"size",configurable:!0})}catch{}var pe=class{constructor(t){D(t,1,"ByteLengthQueuingStrategy"),t=Zr(t,"First parameter"),this._byteLengthQueuingStrategyHighWaterMark=t.highWaterMark}get highWaterMark(){if(!xr(this))throw Kr("highWaterMark");return this._byteLengthQueuingStrategyHighWaterMark}get size(){if(!xr(this))throw Kr("size");return Jr}};Object.defineProperties(pe.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(pe.prototype,m.toStringTag,{value:"ByteLengthQueuingStrategy",configurable:!0});function Kr(e){return new TypeError(`ByteLengthQueuingStrategy.prototype.${e} can only be used on a ByteLengthQueuingStrategy`)}function xr(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_byteLengthQueuingStrategyHighWaterMark")?!1:e instanceof pe}var en=()=>1;try{Object.defineProperty(en,"name",{value:"size",configurable:!0})}catch{}var ye=class{constructor(t){D(t,1,"CountQueuingStrategy"),t=Zr(t,"First parameter"),this._countQueuingStrategyHighWaterMark=t.highWaterMark}get highWaterMark(){if(!rn(this))throw tn("highWaterMark");return this._countQueuingStrategyHighWaterMark}get size(){if(!rn(this))throw tn("size");return en}};Object.defineProperties(ye.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(ye.prototype,m.toStringTag,{value:"CountQueuingStrategy",configurable:!0});function tn(e){return new TypeError(`CountQueuingStrategy.prototype.${e} can only be used on a CountQueuingStrategy`)}function rn(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_countQueuingStrategyHighWaterMark")?!1:e instanceof ye}function Ta(e,t){F(e,t);let r=e==null?void 0:e.flush,n=e==null?void 0:e.readableType,a=e==null?void 0:e.start,o=e==null?void 0:e.transform,i=e==null?void 0:e.writableType;return{flush:r===void 0?void 0:va(r,e,`${t} has member 'flush' that`),readableType:n,start:a===void 0?void 0:Ea(a,e,`${t} has member 'start' that`),transform:o===void 0?void 0:Wa(o,e,`${t} has member 'transform' that`),writableType:i}}function va(e,t,r){return W(e,r),n=>Z(e,t,[n])}function Ea(e,t,r){return W(e,r),n=>Oe(e,t,[n])}function Wa(e,t,r){return W(e,r),(n,a)=>Z(e,t,[n,a])}var Se=class{constructor(t={},r={},n={}){t===void 0&&(t=null);let a=He(r,"Second parameter"),o=He(n,"Third parameter"),i=Ta(t,"First parameter");if(i.readableType!==void 0)throw new RangeError("Invalid readableType specified");if(i.writableType!==void 0)throw new RangeError("Invalid writableType specified");let s=Te(o,0),d=Ue(o),c=Te(a,1),b=Ue(a),h,y=S(v=>{h=v});qa(this,y,c,b,s,d),ka(this,i),i.start!==void 0?h(i.start(this._transformStreamController)):h(void 0)}get readable(){if(!nn(this))throw un("readable");return this._readable}get writable(){if(!nn(this))throw un("writable");return this._writable}};Object.defineProperties(Se.prototype,{readable:{enumerable:!0},writable:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(Se.prototype,m.toStringTag,{value:"TransformStream",configurable:!0});function qa(e,t,r,n,a,o){function i(){return t}function s(y){return ja(e,y)}function d(y){return za(e,y)}function c(){return Ia(e)}e._writable=Dn(i,s,c,d,r,n);function b(){return Fa(e)}function h(y){return at(e,y),_(void 0)}e._readable=Qt(i,b,h,a,o),e._backpressure=void 0,e._backpressureChangePromise=void 0,e._backpressureChangePromise_resolve=void 0,ot(e,!0),e._transformStreamController=void 0}function nn(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_transformStreamController")?!1:e instanceof Se}function nt(e,t){Y(e._readable._readableStreamController,t),at(e,t)}function at(e,t){an(e._transformStreamController),It(e._writable._writableStreamController,t),e._backpressure&&ot(e,!1)}function ot(e,t){e._backpressureChangePromise!==void 0&&e._backpressureChangePromise_resolve(),e._backpressureChangePromise=S(r=>{e._backpressureChangePromise_resolve=r}),e._backpressure=t}var se=class{constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!it(this))throw st("desiredSize");let t=this._controlledTransformStream._readable._readableStreamController;return Nt(t)}enqueue(t=void 0){if(!it(this))throw st("enqueue");on(this,t)}error(t=void 0){if(!it(this))throw st("error");Ba(this,t)}terminate(){if(!it(this))throw st("terminate");Oa(this)}};Object.defineProperties(se.prototype,{enqueue:{enumerable:!0},error:{enumerable:!0},terminate:{enumerable:!0},desiredSize:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(se.prototype,m.toStringTag,{value:"TransformStreamDefaultController",configurable:!0});function it(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledTransformStream")?!1:e instanceof se}function Aa(e,t,r,n){t._controlledTransformStream=e,e._transformStreamController=t,t._transformAlgorithm=r,t._flushAlgorithm=n}function ka(e,t){let r=Object.create(se.prototype),n=o=>{try{return on(r,o),_(void 0)}catch(i){return l(i)}},a=()=>_(void 0);t.transform!==void 0&&(n=o=>t.transform(o,r)),t.flush!==void 0&&(a=()=>t.flush(r)),Aa(e,r,n,a)}function an(e){e._transformAlgorithm=void 0,e._flushAlgorithm=void 0}function on(e,t){let r=e._controlledTransformStream,n=r._readable._readableStreamController;if(!_e(n))throw new TypeError("Readable side is not in a state that permits enqueue");try{tt(n,t)}catch(o){throw at(r,o),r._readable._storedError}da(n)!==r._backpressure&&ot(r,!0)}function Ba(e,t){nt(e._controlledTransformStream,t)}function sn(e,t){let r=e._transformAlgorithm(t);return X(r,void 0,n=>{throw nt(e._controlledTransformStream,n),n})}function Oa(e){let t=e._controlledTransformStream,r=t._readable._readableStreamController;We(r);let n=new TypeError("TransformStream terminated");at(t,n)}function ja(e,t){let r=e._transformStreamController;if(e._backpressure){let n=e._backpressureChangePromise;return X(n,()=>{let a=e._writable;if(a._state==="erroring")throw a._storedError;return sn(r,t)})}return sn(r,t)}function za(e,t){return nt(e,t),_(void 0)}function Ia(e){let t=e._readable,r=e._transformStreamController,n=r._flushAlgorithm();return an(r),X(n,()=>{if(t._state==="errored")throw t._storedError;We(t._readableStreamController)},a=>{throw nt(e,a),t._storedError})}function Fa(e){return ot(e,!1),e._backpressureChangePromise}function st(e){return new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`)}function un(e){return new TypeError(`TransformStream.prototype.${e} can only be used on a TransformStream`)}var Ht={ReadableStream:A,ReadableStreamDefaultController:H,ReadableByteStreamController:N,ReadableStreamBYOBRequest:K,ReadableStreamDefaultReader:J,ReadableStreamBYOBReader:te,WritableStream:Q,WritableStreamDefaultController:U,WritableStreamDefaultWriter:ne,ByteLengthQueuingStrategy:pe,CountQueuingStrategy:ye,TransformStream:Se,TransformStreamDefaultController:se};if(typeof ke!="undefined")for(let e in Ht)Object.prototype.hasOwnProperty.call(Ht,e)&&Object.defineProperty(ke,e,{value:Ht[e],writable:!0,configurable:!0});globalThis.ReadableStream=A,globalThis.WritableStream=Q;})(); +(()=>{var{apply:ln,construct:dn}=Reflect;Function.prototype.once||Object.defineProperty(Function.prototype,"once",{writable:!0,configurable:!0,value(){let e=this,t=!0,r;return function n(){return t&&(t=!1,r=this instanceof n?dn(e,arguments):ln(e,this,arguments)),r}}});var m=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?Symbol:e=>`Symbol(${e})`;function lt(){}function fn(){if(typeof self!="undefined")return self;if(typeof window!="undefined")return window;if(typeof global!="undefined")return global}var ke=fn();function w(e){return typeof e=="object"&&e!==null||typeof e=="function"}var Vt=lt,dt=Promise,cn=Promise.prototype.then,bn=Promise.resolve.bind(dt),hn=Promise.reject.bind(dt);function S(e){return new dt(e)}function _(e){return bn(e)}function l(e){return hn(e)}function z(e,t,r){return cn.call(e,t,r)}function E(e,t,r){z(z(e,t,r),void 0,Vt)}function ft(e,t){E(e,t)}function ct(e,t){E(e,void 0,t)}function X(e,t,r){return z(e,t,r)}function ge(e){z(e,void 0,Vt)}var Be=(()=>{let e=ke&&ke.queueMicrotask;if(typeof e=="function")return e;let t=_(void 0);return r=>z(t,r)})();function Oe(e,t,r){if(typeof e!="function")throw new TypeError("Argument is not a function");return Function.prototype.apply.call(e,t,r)}function Z(e,t,r){try{return _(Oe(e,t,r))}catch(n){return l(n)}}var Gt=16384,T=class{constructor(){this._cursor=0,this._size=0,this._front={_elements:[],_next:void 0},this._back=this._front,this._cursor=0,this._size=0}get length(){return this._size}push(t){let r=this._back,n=r;r._elements.length===Gt-1&&(n={_elements:[],_next:void 0}),r._elements.push(t),n!==r&&(this._back=n,r._next=n),++this._size}shift(){let t=this._front,r=t,n=this._cursor,a=n+1,o=t._elements,i=o[n];return a===Gt&&(r=t._next,a=0),--this._size,this._cursor=a,t!==r&&(this._front=r),o[n]=void 0,i}forEach(t){let r=this._cursor,n=this._front,a=n._elements;for(;(r!==a.length||n._next!==void 0)&&!(r===a.length&&(n=n._next,a=n._elements,r=0,a.length===0));)t(a[r]),++r}peek(){let t=this._front,r=this._cursor;return t._elements[r]}};function Xt(e,t){e._ownerReadableStream=t,t._reader=e,t._state==="readable"?ht(e):t._state==="closed"?mn(e):Zt(e,t._storedError)}function bt(e,t){let r=e._ownerReadableStream;return k(r,t)}function I(e){e._ownerReadableStream._state==="readable"?mt(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")):_n(e,new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")),e._ownerReadableStream._reader=void 0,e._ownerReadableStream=void 0}function ce(e){return new TypeError("Cannot "+e+" a stream using a released reader")}function ht(e){e._closedPromise=S((t,r)=>{e._closedPromise_resolve=t,e._closedPromise_reject=r})}function Zt(e,t){ht(e),mt(e,t)}function mn(e){ht(e),Jt(e)}function mt(e,t){e._closedPromise_reject!==void 0&&(ge(e._closedPromise),e._closedPromise_reject(t),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}function _n(e,t){Zt(e,t)}function Jt(e){e._closedPromise_resolve!==void 0&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0)}var Kt=m("[[AbortSteps]]"),xt=m("[[ErrorSteps]]"),_t=m("[[CancelSteps]]"),pt=m("[[PullSteps]]"),er=Number.isFinite||function(e){return typeof e=="number"&&isFinite(e)},pn=Math.trunc||function(e){return e<0?Math.ceil(e):Math.floor(e)};function yn(e){return typeof e=="object"||typeof e=="function"}function F(e,t){if(e!==void 0&&!yn(e))throw new TypeError(`${t} is not an object.`)}function W(e,t){if(typeof e!="function")throw new TypeError(`${t} is not a function.`)}function Sn(e){return typeof e=="object"&&e!==null||typeof e=="function"}function tr(e,t){if(!Sn(e))throw new TypeError(`${t} is not an object.`)}function D(e,t,r){if(e===void 0)throw new TypeError(`Parameter ${t} is required in '${r}'.`)}function yt(e,t,r){if(e===void 0)throw new TypeError(`${t} is required in '${r}'.`)}function St(e){return Number(e)}function rr(e){return e===0?0:e}function gn(e){return rr(pn(e))}function nr(e,t){let r=0,n=Number.MAX_SAFE_INTEGER,a=Number(e);if(a=rr(a),!er(a))throw new TypeError(`${t} is not a finite number`);if(a=gn(a),an)throw new TypeError(`${t} is outside the accepted range of ${r} to ${n}, inclusive`);return!er(a)||a===0?0:a}function gt(e,t){if(!V(e))throw new TypeError(`${t} is not a ReadableStream.`)}function be(e){return new J(e)}function ar(e,t){e._reader._readRequests.push(t)}function Rt(e,t,r){let a=e._reader._readRequests.shift();r?a._closeSteps():a._chunkSteps(t)}function je(e){return e._reader._readRequests.length}function or(e){let t=e._reader;return!(t===void 0||!$(t))}var J=class{constructor(t){if(D(t,1,"ReadableStreamDefaultReader"),gt(t,"First parameter"),G(t))throw new TypeError("This stream has already been locked for exclusive reading by another reader");Xt(this,t),this._readRequests=new T}get closed(){return $(this)?this._closedPromise:l(ze("closed"))}cancel(t=void 0){return $(this)?this._ownerReadableStream===void 0?l(ce("cancel")):bt(this,t):l(ze("cancel"))}read(){if(!$(this))return l(ze("read"));if(this._ownerReadableStream===void 0)return l(ce("read from"));let t,r,n=S((o,i)=>{t=o,r=i});return Re(this,{_chunkSteps:o=>t({value:o,done:!1}),_closeSteps:()=>t({value:void 0,done:!0}),_errorSteps:o=>r(o)}),n}releaseLock(){if(!$(this))throw ze("releaseLock");if(this._ownerReadableStream!==void 0){if(this._readRequests.length>0)throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");I(this)}}};Object.defineProperties(J.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(J.prototype,m.toStringTag,{value:"ReadableStreamDefaultReader",configurable:!0});function $(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_readRequests")?!1:e instanceof J}function Re(e,t){let r=e._ownerReadableStream;r._disturbed=!0,r._state==="closed"?t._closeSteps():r._state==="errored"?t._errorSteps(r._storedError):r._readableStreamController[pt](t)}function ze(e){return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`)}var ir=Object.getPrototypeOf(Object.getPrototypeOf(async function*(){}).prototype),wt=class{constructor(t,r){this._ongoingPromise=void 0,this._isFinished=!1,this._reader=t,this._preventCancel=r}next(){let t=()=>this._nextSteps();return this._ongoingPromise=this._ongoingPromise?X(this._ongoingPromise,t,t):t(),this._ongoingPromise}return(t){let r=()=>this._returnSteps(t);return this._ongoingPromise?X(this._ongoingPromise,r,r):r()}_nextSteps(){if(this._isFinished)return Promise.resolve({value:void 0,done:!0});let t=this._reader;if(t._ownerReadableStream===void 0)return l(ce("iterate"));let r,n,a=S((i,s)=>{r=i,n=s});return Re(t,{_chunkSteps:i=>{this._ongoingPromise=void 0,Be(()=>r({value:i,done:!1}))},_closeSteps:()=>{this._ongoingPromise=void 0,this._isFinished=!0,I(t),r({value:void 0,done:!0})},_errorSteps:i=>{this._ongoingPromise=void 0,this._isFinished=!0,I(t),n(i)}}),a}_returnSteps(t){if(this._isFinished)return Promise.resolve({value:t,done:!0});this._isFinished=!0;let r=this._reader;if(r._ownerReadableStream===void 0)return l(ce("finish iterating"));if(!this._preventCancel){let n=bt(r,t);return I(r),X(n,()=>({value:t,done:!0}))}return I(r),_({value:t,done:!0})}},sr={next(){return ur(this)?this._asyncIteratorImpl.next():l(lr("next"))},return(e){return ur(this)?this._asyncIteratorImpl.return(e):l(lr("return"))}};ir!==void 0&&Object.setPrototypeOf(sr,ir);function Rn(e,t){let r=be(e),n=new wt(r,t),a=Object.create(sr);return a._asyncIteratorImpl=n,a}function ur(e){if(!w(e)||!Object.prototype.hasOwnProperty.call(e,"_asyncIteratorImpl"))return!1;try{return e._asyncIteratorImpl instanceof wt}catch{return!1}}function lr(e){return new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`)}var dr=Number.isNaN||function(e){return e!==e};function we(e){return e.slice()}function fr(e,t,r,n,a){new Uint8Array(e).set(new Uint8Array(r,n,a),t)}function $a(e){return e}function Ie(e){return!1}function cr(e,t,r){if(e.slice)return e.slice(t,r);let n=r-t,a=new ArrayBuffer(n);return fr(a,0,e,t,n),a}function wn(e){return!(typeof e!="number"||dr(e)||e<0)}function br(e){let t=cr(e.buffer,e.byteOffset,e.byteOffset+e.byteLength);return new Uint8Array(t)}function Ct(e){let t=e._queue.shift();return e._queueTotalSize-=t.size,e._queueTotalSize<0&&(e._queueTotalSize=0),t.value}function Pt(e,t,r){if(!wn(r)||r===1/0)throw new RangeError("Size must be a finite, non-NaN, non-negative number.");e._queue.push({value:t,size:r}),e._queueTotalSize+=r}function Cn(e){return e._queue.peek().value}function M(e){e._queue=new T,e._queueTotalSize=0}var K=class{constructor(){throw new TypeError("Illegal constructor")}get view(){if(!Tt(this))throw qt("view");return this._view}respond(t){if(!Tt(this))throw qt("respond");if(D(t,1,"respond"),t=nr(t,"First parameter"),this._associatedReadableByteStreamController===void 0)throw new TypeError("This BYOB request has been invalidated");Ie(this._view.buffer),Me(this._associatedReadableByteStreamController,t)}respondWithNewView(t){if(!Tt(this))throw qt("respondWithNewView");if(D(t,1,"respondWithNewView"),!ArrayBuffer.isView(t))throw new TypeError("You can only respond with array buffer views");if(this._associatedReadableByteStreamController===void 0)throw new TypeError("This BYOB request has been invalidated");Ie(t.buffer),Ne(this._associatedReadableByteStreamController,t)}};Object.defineProperties(K.prototype,{respond:{enumerable:!0},respondWithNewView:{enumerable:!0},view:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(K.prototype,m.toStringTag,{value:"ReadableStreamBYOBRequest",configurable:!0});var N=class{constructor(){throw new TypeError("Illegal constructor")}get byobRequest(){if(!x(this))throw Pe("byobRequest");return Wt(this)}get desiredSize(){if(!x(this))throw Pe("desiredSize");return Rr(this)}close(){if(!x(this))throw Pe("close");if(this._closeRequested)throw new TypeError("The stream has already been closed; do not close it again!");let t=this._controlledReadableByteStream._state;if(t!=="readable")throw new TypeError(`The stream (in ${t} state) is not in the readable state and cannot be closed`);Ce(this)}enqueue(t){if(!x(this))throw Pe("enqueue");if(D(t,1,"enqueue"),!ArrayBuffer.isView(t))throw new TypeError("chunk must be an array buffer view");if(t.byteLength===0)throw new TypeError("chunk must have non-zero byteLength");if(t.buffer.byteLength===0)throw new TypeError("chunk's buffer must have non-zero byteLength");if(this._closeRequested)throw new TypeError("stream is closed or draining");let r=this._controlledReadableByteStream._state;if(r!=="readable")throw new TypeError(`The stream (in ${r} state) is not in the readable state and cannot be enqueued to`);$e(this,t)}error(t=void 0){if(!x(this))throw Pe("error");q(this,t)}[_t](t){hr(this),M(this);let r=this._cancelAlgorithm(t);return Le(this),r}[pt](t){let r=this._controlledReadableByteStream;if(this._queueTotalSize>0){let a=this._queue.shift();this._queueTotalSize-=a.byteLength,yr(this);let o=new Uint8Array(a.buffer,a.byteOffset,a.byteLength);t._chunkSteps(o);return}let n=this._autoAllocateChunkSize;if(n!==void 0){let a;try{a=new ArrayBuffer(n)}catch(i){t._errorSteps(i);return}let o={buffer:a,bufferByteLength:n,byteOffset:0,byteLength:n,bytesFilled:0,elementSize:1,viewConstructor:Uint8Array,readerType:"default"};this._pendingPullIntos.push(o)}ar(r,t),ee(this)}};Object.defineProperties(N.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},byobRequest:{enumerable:!0},desiredSize:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(N.prototype,m.toStringTag,{value:"ReadableByteStreamController",configurable:!0});function x(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledReadableByteStream")?!1:e instanceof N}function Tt(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_associatedReadableByteStreamController")?!1:e instanceof K}function ee(e){if(!En(e))return;if(e._pulling){e._pullAgain=!0;return}e._pulling=!0;let r=e._pullAlgorithm();E(r,()=>{e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,ee(e))},n=>{q(e,n)})}function hr(e){Et(e),e._pendingPullIntos=new T}function vt(e,t){let r=!1;e._state==="closed"&&(r=!0);let n=mr(t);t.readerType==="default"?Rt(e,n,r):An(e,n,r)}function mr(e){let t=e.bytesFilled,r=e.elementSize;return new e.viewConstructor(e.buffer,e.byteOffset,t/r)}function Fe(e,t,r,n){e._queue.push({buffer:t,byteOffset:r,byteLength:n}),e._queueTotalSize+=n}function _r(e,t){let r=t.elementSize,n=t.bytesFilled-t.bytesFilled%r,a=Math.min(e._queueTotalSize,t.byteLength-t.bytesFilled),o=t.bytesFilled+a,i=o-o%r,s=a,d=!1;i>n&&(s=i-t.bytesFilled,d=!0);let c=e._queue;for(;s>0;){let b=c.peek(),h=Math.min(s,b.byteLength),y=t.byteOffset+t.bytesFilled;fr(t.buffer,y,b.buffer,b.byteOffset,h),b.byteLength===h?c.shift():(b.byteOffset+=h,b.byteLength-=h),e._queueTotalSize-=h,pr(e,h,t),s-=h}return d}function pr(e,t,r){r.bytesFilled+=t}function yr(e){e._queueTotalSize===0&&e._closeRequested?(Le(e),qe(e._controlledReadableByteStream)):ee(e)}function Et(e){e._byobRequest!==null&&(e._byobRequest._associatedReadableByteStreamController=void 0,e._byobRequest._view=null,e._byobRequest=null)}function Sr(e){for(;e._pendingPullIntos.length>0;){if(e._queueTotalSize===0)return;let t=e._pendingPullIntos.peek();_r(e,t)&&(De(e),vt(e._controlledReadableByteStream,t))}}function Pn(e,t,r){let n=e._controlledReadableByteStream,a=1;t.constructor!==DataView&&(a=t.constructor.BYTES_PER_ELEMENT);let o=t.constructor,i=t.buffer,s={buffer:i,bufferByteLength:i.byteLength,byteOffset:t.byteOffset,byteLength:t.byteLength,bytesFilled:0,elementSize:a,viewConstructor:o,readerType:"byob"};if(e._pendingPullIntos.length>0){e._pendingPullIntos.push(s),Pr(n,r);return}if(n._state==="closed"){let d=new o(s.buffer,s.byteOffset,0);r._closeSteps(d);return}if(e._queueTotalSize>0){if(_r(e,s)){let d=mr(s);yr(e),r._chunkSteps(d);return}if(e._closeRequested){let d=new TypeError("Insufficient bytes to fill elements in the given buffer");q(e,d),r._errorSteps(d);return}}e._pendingPullIntos.push(s),Pr(n,r),ee(e)}function Tn(e,t){let r=e._controlledReadableByteStream;if(At(r))for(;Tr(r)>0;){let n=De(e);vt(r,n)}}function vn(e,t,r){if(pr(e,t,r),r.bytesFilled0){let a=r.byteOffset+r.bytesFilled,o=cr(r.buffer,a-n,a);Fe(e,o,0,o.byteLength)}r.bytesFilled-=n,vt(e._controlledReadableByteStream,r),Sr(e)}function gr(e,t){let r=e._pendingPullIntos.peek();Et(e),e._controlledReadableByteStream._state==="closed"?Tn(e):vn(e,t,r),ee(e)}function De(e){return e._pendingPullIntos.shift()}function En(e){let t=e._controlledReadableByteStream;return t._state!=="readable"||e._closeRequested||!e._started?!1:!!(or(t)&&je(t)>0||At(t)&&Tr(t)>0||Rr(e)>0)}function Le(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0}function Ce(e){let t=e._controlledReadableByteStream;if(!(e._closeRequested||t._state!=="readable")){if(e._queueTotalSize>0){e._closeRequested=!0;return}if(e._pendingPullIntos.length>0&&e._pendingPullIntos.peek().bytesFilled>0){let n=new TypeError("Insufficient bytes to fill elements in the given buffer");throw q(e,n),n}Le(e),qe(t)}}function $e(e,t){let r=e._controlledReadableByteStream;if(e._closeRequested||r._state!=="readable")return;let n=t.buffer,a=t.byteOffset,o=t.byteLength,i=n;if(e._pendingPullIntos.length>0){let s=e._pendingPullIntos.peek();Ie(s.buffer),s.buffer=s.buffer}if(Et(e),or(r))if(je(r)===0)Fe(e,i,a,o);else{e._pendingPullIntos.length>0&&De(e);let s=new Uint8Array(i,a,o);Rt(r,s,!1)}else At(r)?(Fe(e,i,a,o),Sr(e)):Fe(e,i,a,o);ee(e)}function q(e,t){let r=e._controlledReadableByteStream;r._state==="readable"&&(hr(e),M(e),Le(e),Xr(r,t))}function Wt(e){if(e._byobRequest===null&&e._pendingPullIntos.length>0){let t=e._pendingPullIntos.peek(),r=new Uint8Array(t.buffer,t.byteOffset+t.bytesFilled,t.byteLength-t.bytesFilled),n=Object.create(K.prototype);qn(n,e,r),e._byobRequest=n}return e._byobRequest}function Rr(e){let t=e._controlledReadableByteStream._state;return t==="errored"?null:t==="closed"?0:e._strategyHWM-e._queueTotalSize}function Me(e,t){let r=e._pendingPullIntos.peek();if(e._controlledReadableByteStream._state==="closed"){if(t!==0)throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream")}else{if(t===0)throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");if(r.bytesFilled+t>r.byteLength)throw new RangeError("bytesWritten out of range")}r.buffer=r.buffer,gr(e,t)}function Ne(e,t){let r=e._pendingPullIntos.peek();if(e._controlledReadableByteStream._state==="closed"){if(t.byteLength!==0)throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream")}else if(t.byteLength===0)throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");if(r.byteOffset+r.bytesFilled!==t.byteOffset)throw new RangeError("The region specified by view does not match byobRequest");if(r.bufferByteLength!==t.buffer.byteLength)throw new RangeError("The buffer of view has different capacity than byobRequest");if(r.bytesFilled+t.byteLength>r.byteLength)throw new RangeError("The region specified by view is larger than byobRequest");let a=t.byteLength;r.buffer=t.buffer,gr(e,a)}function wr(e,t,r,n,a,o,i){t._controlledReadableByteStream=e,t._pullAgain=!1,t._pulling=!1,t._byobRequest=null,t._queue=t._queueTotalSize=void 0,M(t),t._closeRequested=!1,t._started=!1,t._strategyHWM=o,t._pullAlgorithm=n,t._cancelAlgorithm=a,t._autoAllocateChunkSize=i,t._pendingPullIntos=new T,e._readableStreamController=t;let s=r();E(_(s),()=>{t._started=!0,ee(t)},d=>{q(t,d)})}function Wn(e,t,r){let n=Object.create(N.prototype),a=()=>{},o=()=>_(void 0),i=()=>_(void 0);t.start!==void 0&&(a=()=>t.start(n)),t.pull!==void 0&&(o=()=>t.pull(n)),t.cancel!==void 0&&(i=d=>t.cancel(d));let s=t.autoAllocateChunkSize;if(s===0)throw new TypeError("autoAllocateChunkSize must be greater than 0");wr(e,n,a,o,i,r,s)}function qn(e,t,r){e._associatedReadableByteStreamController=t,e._view=r}function qt(e){return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`)}function Pe(e){return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`)}function Cr(e){return new te(e)}function Pr(e,t){e._reader._readIntoRequests.push(t)}function An(e,t,r){let a=e._reader._readIntoRequests.shift();r?a._closeSteps(t):a._chunkSteps(t)}function Tr(e){return e._reader._readIntoRequests.length}function At(e){let t=e._reader;return!(t===void 0||!re(t))}var te=class{constructor(t){if(D(t,1,"ReadableStreamBYOBReader"),gt(t,"First parameter"),G(t))throw new TypeError("This stream has already been locked for exclusive reading by another reader");if(!x(t._readableStreamController))throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");Xt(this,t),this._readIntoRequests=new T}get closed(){return re(this)?this._closedPromise:l(Qe("closed"))}cancel(t=void 0){return re(this)?this._ownerReadableStream===void 0?l(ce("cancel")):bt(this,t):l(Qe("cancel"))}read(t){if(!re(this))return l(Qe("read"));if(!ArrayBuffer.isView(t))return l(new TypeError("view must be an array buffer view"));if(t.byteLength===0)return l(new TypeError("view must have non-zero byteLength"));if(t.buffer.byteLength===0)return l(new TypeError("view's buffer must have non-zero byteLength"));if(Ie(t.buffer),this._ownerReadableStream===void 0)return l(ce("read from"));let r,n,a=S((i,s)=>{r=i,n=s});return vr(this,t,{_chunkSteps:i=>r({value:i,done:!1}),_closeSteps:i=>r({value:i,done:!0}),_errorSteps:i=>n(i)}),a}releaseLock(){if(!re(this))throw Qe("releaseLock");if(this._ownerReadableStream!==void 0){if(this._readIntoRequests.length>0)throw new TypeError("Tried to release a reader lock when that reader has pending read() calls un-settled");I(this)}}};Object.defineProperties(te.prototype,{cancel:{enumerable:!0},read:{enumerable:!0},releaseLock:{enumerable:!0},closed:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(te.prototype,m.toStringTag,{value:"ReadableStreamBYOBReader",configurable:!0});function re(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_readIntoRequests")?!1:e instanceof te}function vr(e,t,r){let n=e._ownerReadableStream;n._disturbed=!0,n._state==="errored"?r._errorSteps(n._storedError):Pn(n._readableStreamController,t,r)}function Qe(e){return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`)}function Te(e,t){let{highWaterMark:r}=e;if(r===void 0)return t;if(dr(r)||r<0)throw new RangeError("Invalid highWaterMark");return r}function Ue(e){let{size:t}=e;return t||(()=>1)}function He(e,t){F(e,t);let r=e==null?void 0:e.highWaterMark,n=e==null?void 0:e.size;return{highWaterMark:r===void 0?void 0:St(r),size:n===void 0?void 0:kn(n,`${t} has member 'size' that`)}}function kn(e,t){return W(e,t),r=>St(e(r))}function Bn(e,t){F(e,t);let r=e==null?void 0:e.abort,n=e==null?void 0:e.close,a=e==null?void 0:e.start,o=e==null?void 0:e.type,i=e==null?void 0:e.write;return{abort:r===void 0?void 0:On(r,e,`${t} has member 'abort' that`),close:n===void 0?void 0:jn(n,e,`${t} has member 'close' that`),start:a===void 0?void 0:zn(a,e,`${t} has member 'start' that`),write:i===void 0?void 0:In(i,e,`${t} has member 'write' that`),type:o}}function On(e,t,r){return W(e,r),n=>Z(e,t,[n])}function jn(e,t,r){return W(e,r),()=>Z(e,t,[])}function zn(e,t,r){return W(e,r),n=>Oe(e,t,[n])}function In(e,t,r){return W(e,r),(n,a)=>Z(e,t,[n,a])}function Er(e,t){if(!he(e))throw new TypeError(`${t} is not a WritableStream.`)}function Fn(e){if(typeof e!="object"||e===null)return!1;try{return typeof e.aborted=="boolean"}catch{return!1}}var Dn=typeof AbortController=="function";function Ln(){if(Dn)return new AbortController}var Q=class{constructor(t={},r={}){t===void 0?t=null:tr(t,"First parameter");let n=He(r,"Second parameter"),a=Bn(t,"First parameter");if(qr(this),a.type!==void 0)throw new RangeError("Invalid type is specified");let i=Ue(n),s=Te(n,1);xn(this,a,s,i)}get locked(){if(!he(this))throw Ze("locked");return me(this)}abort(t=void 0){return he(this)?me(this)?l(new TypeError("Cannot abort a stream that already has a writer")):Ye(this,t):l(Ze("abort"))}close(){return he(this)?me(this)?l(new TypeError("Cannot close a stream that already has a writer")):B(this)?l(new TypeError("Cannot close an already-closing stream")):Ar(this):l(Ze("close"))}getWriter(){if(!he(this))throw Ze("getWriter");return Wr(this)}};Object.defineProperties(Q.prototype,{abort:{enumerable:!0},close:{enumerable:!0},getWriter:{enumerable:!0},locked:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(Q.prototype,m.toStringTag,{value:"WritableStream",configurable:!0});function Wr(e){return new ne(e)}function $n(e,t,r,n,a=1,o=()=>1){let i=Object.create(Q.prototype);qr(i);let s=Object.create(U.prototype);return Ir(i,s,e,t,r,n,a,o),i}function qr(e){e._state="writable",e._storedError=void 0,e._writer=void 0,e._writableStreamController=void 0,e._writeRequests=new T,e._inFlightWriteRequest=void 0,e._closeRequest=void 0,e._inFlightCloseRequest=void 0,e._pendingAbortRequest=void 0,e._backpressure=!1}function he(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_writableStreamController")?!1:e instanceof Q}function me(e){return e._writer!==void 0}function Ye(e,t){var r;if(e._state==="closed"||e._state==="errored")return _(void 0);e._writableStreamController._abortReason=t,(r=e._writableStreamController._abortController)===null||r===void 0||r.abort();let n=e._state;if(n==="closed"||n==="errored")return _(void 0);if(e._pendingAbortRequest!==void 0)return e._pendingAbortRequest._promise;let a=!1;n==="erroring"&&(a=!0,t=void 0);let o=S((i,s)=>{e._pendingAbortRequest={_promise:void 0,_resolve:i,_reject:s,_reason:t,_wasAlreadyErroring:a}});return e._pendingAbortRequest._promise=o,a||Bt(e,t),o}function Ar(e){let t=e._state;if(t==="closed"||t==="errored")return l(new TypeError(`The stream (in ${t} state) is not in the writable state and cannot be closed`));let r=S((a,o)=>{let i={_resolve:a,_reject:o};e._closeRequest=i}),n=e._writer;return n!==void 0&&e._backpressure&&t==="writable"&&Mt(n),ea(e._writableStreamController),r}function Mn(e){return S((r,n)=>{let a={_resolve:r,_reject:n};e._writeRequests.push(a)})}function kt(e,t){if(e._state==="writable"){Bt(e,t);return}Ot(e)}function Bt(e,t){let r=e._writableStreamController;e._state="erroring",e._storedError=t;let n=e._writer;n!==void 0&&Br(n,t),!Yn(e)&&r._started&&Ot(e)}function Ot(e){e._state="errored",e._writableStreamController[xt]();let t=e._storedError;if(e._writeRequests.forEach(a=>{a._reject(t)}),e._writeRequests=new T,e._pendingAbortRequest===void 0){Ve(e);return}let r=e._pendingAbortRequest;if(e._pendingAbortRequest=void 0,r._wasAlreadyErroring){r._reject(t),Ve(e);return}let n=e._writableStreamController[Kt](r._reason);E(n,()=>{r._resolve(),Ve(e)},a=>{r._reject(a),Ve(e)})}function Nn(e){e._inFlightWriteRequest._resolve(void 0),e._inFlightWriteRequest=void 0}function Qn(e,t){e._inFlightWriteRequest._reject(t),e._inFlightWriteRequest=void 0,kt(e,t)}function Un(e){e._inFlightCloseRequest._resolve(void 0),e._inFlightCloseRequest=void 0,e._state==="erroring"&&(e._storedError=void 0,e._pendingAbortRequest!==void 0&&(e._pendingAbortRequest._resolve(),e._pendingAbortRequest=void 0)),e._state="closed";let r=e._writer;r!==void 0&&$r(r)}function Hn(e,t){e._inFlightCloseRequest._reject(t),e._inFlightCloseRequest=void 0,e._pendingAbortRequest!==void 0&&(e._pendingAbortRequest._reject(t),e._pendingAbortRequest=void 0),kt(e,t)}function B(e){return!(e._closeRequest===void 0&&e._inFlightCloseRequest===void 0)}function Yn(e){return!(e._inFlightWriteRequest===void 0&&e._inFlightCloseRequest===void 0)}function Vn(e){e._inFlightCloseRequest=e._closeRequest,e._closeRequest=void 0}function Gn(e){e._inFlightWriteRequest=e._writeRequests.shift()}function Ve(e){e._closeRequest!==void 0&&(e._closeRequest._reject(e._storedError),e._closeRequest=void 0);let t=e._writer;t!==void 0&&Lt(t,e._storedError)}function jt(e,t){let r=e._writer;r!==void 0&&t!==e._backpressure&&(t?sa(r):Mt(r)),e._backpressure=t}var ne=class{constructor(t){if(D(t,1,"WritableStreamDefaultWriter"),Er(t,"First parameter"),me(t))throw new TypeError("This stream has already been locked for exclusive writing by another writer");this._ownerWritableStream=t,t._writer=this;let r=t._state;if(r==="writable")!B(t)&&t._backpressure?Ke(this):Mr(this),Je(this);else if(r==="erroring")$t(this,t._storedError),Je(this);else if(r==="closed")Mr(this),oa(this);else{let n=t._storedError;$t(this,n),Lr(this,n)}}get closed(){return ae(this)?this._closedPromise:l(oe("closed"))}get desiredSize(){if(!ae(this))throw oe("desiredSize");if(this._ownerWritableStream===void 0)throw ve("desiredSize");return Kn(this)}get ready(){return ae(this)?this._readyPromise:l(oe("ready"))}abort(t=void 0){return ae(this)?this._ownerWritableStream===void 0?l(ve("abort")):Xn(this,t):l(oe("abort"))}close(){if(!ae(this))return l(oe("close"));let t=this._ownerWritableStream;return t===void 0?l(ve("close")):B(t)?l(new TypeError("Cannot close an already-closing stream")):kr(this)}releaseLock(){if(!ae(this))throw oe("releaseLock");this._ownerWritableStream!==void 0&&Or(this)}write(t=void 0){return ae(this)?this._ownerWritableStream===void 0?l(ve("write to")):jr(this,t):l(oe("write"))}};Object.defineProperties(ne.prototype,{abort:{enumerable:!0},close:{enumerable:!0},releaseLock:{enumerable:!0},write:{enumerable:!0},closed:{enumerable:!0},desiredSize:{enumerable:!0},ready:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(ne.prototype,m.toStringTag,{value:"WritableStreamDefaultWriter",configurable:!0});function ae(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_ownerWritableStream")?!1:e instanceof ne}function Xn(e,t){let r=e._ownerWritableStream;return Ye(r,t)}function kr(e){let t=e._ownerWritableStream;return Ar(t)}function Zn(e){let t=e._ownerWritableStream,r=t._state;return B(t)||r==="closed"?_(void 0):r==="errored"?l(t._storedError):kr(e)}function Jn(e,t){e._closedPromiseState==="pending"?Lt(e,t):ia(e,t)}function Br(e,t){e._readyPromiseState==="pending"?Nr(e,t):ua(e,t)}function Kn(e){let t=e._ownerWritableStream,r=t._state;return r==="errored"||r==="erroring"?null:r==="closed"?0:Fr(t._writableStreamController)}function Or(e){let t=e._ownerWritableStream,r=new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");Br(e,r),Jn(e,r),t._writer=void 0,e._ownerWritableStream=void 0}function jr(e,t){let r=e._ownerWritableStream,n=r._writableStreamController,a=ta(n,t);if(r!==e._ownerWritableStream)return l(ve("write to"));let o=r._state;if(o==="errored")return l(r._storedError);if(B(r)||o==="closed")return l(new TypeError("The stream is closing or closed and cannot be written to"));if(o==="erroring")return l(r._storedError);let i=Mn(r);return ra(n,t,a),i}var zr={},U=class{constructor(){throw new TypeError("Illegal constructor")}get abortReason(){if(!zt(this))throw Dt("abortReason");return this._abortReason}get signal(){if(!zt(this))throw Dt("signal");if(this._abortController===void 0)throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");return this._abortController.signal}error(t=void 0){if(!zt(this))throw Dt("error");this._controlledWritableStream._state==="writable"&&Dr(this,t)}[Kt](t){let r=this._abortAlgorithm(t);return Ge(this),r}[xt](){M(this)}};Object.defineProperties(U.prototype,{abortReason:{enumerable:!0},signal:{enumerable:!0},error:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(U.prototype,m.toStringTag,{value:"WritableStreamDefaultController",configurable:!0});function zt(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledWritableStream")?!1:e instanceof U}function Ir(e,t,r,n,a,o,i,s){t._controlledWritableStream=e,e._writableStreamController=t,t._queue=void 0,t._queueTotalSize=void 0,M(t),t._abortReason=void 0,t._abortController=Ln(),t._started=!1,t._strategySizeAlgorithm=s,t._strategyHWM=i,t._writeAlgorithm=n,t._closeAlgorithm=a,t._abortAlgorithm=o;let d=Ft(t);jt(e,d);let c=r(),b=_(c);E(b,()=>{t._started=!0,Xe(t)},h=>{t._started=!0,kt(e,h)})}function xn(e,t,r,n){let a=Object.create(U.prototype),o=()=>{},i=()=>_(void 0),s=()=>_(void 0),d=()=>_(void 0);t.start!==void 0&&(o=()=>t.start(a)),t.write!==void 0&&(i=c=>t.write(c,a)),t.close!==void 0&&(s=()=>t.close()),t.abort!==void 0&&(d=c=>t.abort(c)),Ir(e,a,o,i,s,d,r,n)}function Ge(e){e._writeAlgorithm=void 0,e._closeAlgorithm=void 0,e._abortAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function ea(e){Pt(e,zr,0),Xe(e)}function ta(e,t){try{return e._strategySizeAlgorithm(t)}catch(r){return It(e,r),1}}function Fr(e){return e._strategyHWM-e._queueTotalSize}function ra(e,t,r){try{Pt(e,t,r)}catch(a){It(e,a);return}let n=e._controlledWritableStream;if(!B(n)&&n._state==="writable"){let a=Ft(e);jt(n,a)}Xe(e)}function Xe(e){let t=e._controlledWritableStream;if(!e._started||t._inFlightWriteRequest!==void 0)return;if(t._state==="erroring"){Ot(t);return}if(e._queue.length===0)return;let n=Cn(e);n===zr?na(e):aa(e,n)}function It(e,t){e._controlledWritableStream._state==="writable"&&Dr(e,t)}function na(e){let t=e._controlledWritableStream;Vn(t),Ct(e);let r=e._closeAlgorithm();Ge(e),E(r,()=>{Un(t)},n=>{Hn(t,n)})}function aa(e,t){let r=e._controlledWritableStream;Gn(r);let n=e._writeAlgorithm(t);E(n,()=>{Nn(r);let a=r._state;if(Ct(e),!B(r)&&a==="writable"){let o=Ft(e);jt(r,o)}Xe(e)},a=>{r._state==="writable"&&Ge(e),Qn(r,a)})}function Ft(e){return Fr(e)<=0}function Dr(e,t){let r=e._controlledWritableStream;Ge(e),Bt(r,t)}function Ze(e){return new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`)}function Dt(e){return new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`)}function oe(e){return new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`)}function ve(e){return new TypeError("Cannot "+e+" a stream using a released writer")}function Je(e){e._closedPromise=S((t,r)=>{e._closedPromise_resolve=t,e._closedPromise_reject=r,e._closedPromiseState="pending"})}function Lr(e,t){Je(e),Lt(e,t)}function oa(e){Je(e),$r(e)}function Lt(e,t){e._closedPromise_reject!==void 0&&(ge(e._closedPromise),e._closedPromise_reject(t),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="rejected")}function ia(e,t){Lr(e,t)}function $r(e){e._closedPromise_resolve!==void 0&&(e._closedPromise_resolve(void 0),e._closedPromise_resolve=void 0,e._closedPromise_reject=void 0,e._closedPromiseState="resolved")}function Ke(e){e._readyPromise=S((t,r)=>{e._readyPromise_resolve=t,e._readyPromise_reject=r}),e._readyPromiseState="pending"}function $t(e,t){Ke(e),Nr(e,t)}function Mr(e){Ke(e),Mt(e)}function Nr(e,t){e._readyPromise_reject!==void 0&&(ge(e._readyPromise),e._readyPromise_reject(t),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="rejected")}function sa(e){Ke(e)}function ua(e,t){$t(e,t)}function Mt(e){e._readyPromise_resolve!==void 0&&(e._readyPromise_resolve(void 0),e._readyPromise_resolve=void 0,e._readyPromise_reject=void 0,e._readyPromiseState="fulfilled")}var Qr=typeof DOMException!="undefined"?DOMException:void 0;function la(e){if(!(typeof e=="function"||typeof e=="object"))return!1;try{return new e,!0}catch{return!1}}function da(){let e=function(r,n){this.message=r||"",this.name=n||"Error",Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)};return e.prototype=Object.create(Error.prototype),Object.defineProperty(e.prototype,"constructor",{value:e,writable:!0,configurable:!0}),e}var fa=la(Qr)?Qr:da();function Ur(e,t,r,n,a,o){let i=be(e),s=Wr(t);e._disturbed=!0;let d=!1,c=_(void 0);return S((b,h)=>{let y;if(o!==void 0){if(y=()=>{let u=new fa("Aborted","AbortError"),f=[];n||f.push(()=>t._state==="writable"?Ye(t,u):_(void 0)),a||f.push(()=>e._state==="readable"?k(e,u):_(void 0)),R(()=>Promise.all(f.map(p=>p())),!0,u)},o.aborted){y();return}o.addEventListener("abort",y)}function v(){return S((u,f)=>{function p(C){C?u():z(ue(),p,f)}p(!1)})}function ue(){return d?_(!0):z(s._readyPromise,()=>S((u,f)=>{Re(i,{_chunkSteps:p=>{c=z(jr(s,p),void 0,lt),u(!1)},_closeSteps:()=>u(!0),_errorSteps:f})}))}if(O(e,i._closedPromise,u=>{n?P(!0,u):R(()=>Ye(t,u),!0,u)}),O(t,s._closedPromise,u=>{a?P(!0,u):R(()=>k(e,u),!0,u)}),g(e,i._closedPromise,()=>{r?P():R(()=>Zn(s))}),B(t)||t._state==="closed"){let u=new TypeError("the destination writable stream closed before all data could be piped to it");a?P(!0,u):R(()=>k(e,u),!0,u)}ge(v());function L(){let u=c;return z(c,()=>u!==c?L():void 0)}function O(u,f,p){u._state==="errored"?p(u._storedError):ct(f,p)}function g(u,f,p){u._state==="closed"?p():ft(f,p)}function R(u,f,p){if(d)return;d=!0,t._state==="writable"&&!B(t)?ft(L(),C):C();function C(){E(u(),()=>j(f,p),le=>j(!0,le))}}function P(u,f){d||(d=!0,t._state==="writable"&&!B(t)?ft(L(),()=>j(u,f)):j(u,f))}function j(u,f){Or(s),I(i),o!==void 0&&o.removeEventListener("abort",y),u?h(f):b(void 0)}})}var H=class{constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!xe(this))throw rt("desiredSize");return Nt(this)}close(){if(!xe(this))throw rt("close");if(!_e(this))throw new TypeError("The stream is not in a state that permits close");We(this)}enqueue(t=void 0){if(!xe(this))throw rt("enqueue");if(!_e(this))throw new TypeError("The stream is not in a state that permits enqueue");return tt(this,t)}error(t=void 0){if(!xe(this))throw rt("error");Y(this,t)}[_t](t){M(this);let r=this._cancelAlgorithm(t);return et(this),r}[pt](t){let r=this._controlledReadableStream;if(this._queue.length>0){let n=Ct(this);this._closeRequested&&this._queue.length===0?(et(this),qe(r)):Ee(this),t._chunkSteps(n)}else ar(r,t),Ee(this)}};Object.defineProperties(H.prototype,{close:{enumerable:!0},enqueue:{enumerable:!0},error:{enumerable:!0},desiredSize:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(H.prototype,m.toStringTag,{value:"ReadableStreamDefaultController",configurable:!0});function xe(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledReadableStream")?!1:e instanceof H}function Ee(e){if(!Hr(e))return;if(e._pulling){e._pullAgain=!0;return}e._pulling=!0;let r=e._pullAlgorithm();E(r,()=>{e._pulling=!1,e._pullAgain&&(e._pullAgain=!1,Ee(e))},n=>{Y(e,n)})}function Hr(e){let t=e._controlledReadableStream;return!_e(e)||!e._started?!1:!!(G(t)&&je(t)>0||Nt(e)>0)}function et(e){e._pullAlgorithm=void 0,e._cancelAlgorithm=void 0,e._strategySizeAlgorithm=void 0}function We(e){if(!_e(e))return;let t=e._controlledReadableStream;e._closeRequested=!0,e._queue.length===0&&(et(e),qe(t))}function tt(e,t){if(!_e(e))return;let r=e._controlledReadableStream;if(G(r)&&je(r)>0)Rt(r,t,!1);else{let n;try{n=e._strategySizeAlgorithm(t)}catch(a){throw Y(e,a),a}try{Pt(e,t,n)}catch(a){throw Y(e,a),a}}Ee(e)}function Y(e,t){let r=e._controlledReadableStream;r._state==="readable"&&(M(e),et(e),Xr(r,t))}function Nt(e){let t=e._controlledReadableStream._state;return t==="errored"?null:t==="closed"?0:e._strategyHWM-e._queueTotalSize}function ca(e){return!Hr(e)}function _e(e){let t=e._controlledReadableStream._state;return!e._closeRequested&&t==="readable"}function Yr(e,t,r,n,a,o,i){t._controlledReadableStream=e,t._queue=void 0,t._queueTotalSize=void 0,M(t),t._started=!1,t._closeRequested=!1,t._pullAgain=!1,t._pulling=!1,t._strategySizeAlgorithm=i,t._strategyHWM=o,t._pullAlgorithm=n,t._cancelAlgorithm=a,e._readableStreamController=t;let s=r();E(_(s),()=>{t._started=!0,Ee(t)},d=>{Y(t,d)})}function ba(e,t,r,n){let a=Object.create(H.prototype),o=()=>{},i=()=>_(void 0),s=()=>_(void 0);t.start!==void 0&&(o=()=>t.start(a)),t.pull!==void 0&&(i=()=>t.pull(a)),t.cancel!==void 0&&(s=d=>t.cancel(d)),Yr(e,a,o,i,s,r,n)}function rt(e){return new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`)}function ha(e,t){return x(e._readableStreamController)?_a(e):ma(e)}function ma(e,t){let r=be(e),n=!1,a=!1,o=!1,i=!1,s,d,c,b,h,y=S(g=>{h=g});function v(){return n?(a=!0,_(void 0)):(n=!0,Re(r,{_chunkSteps:R=>{Be(()=>{a=!1;let P=R,j=R;o||tt(c._readableStreamController,P),i||tt(b._readableStreamController,j),n=!1,a&&v()})},_closeSteps:()=>{n=!1,o||We(c._readableStreamController),i||We(b._readableStreamController),(!o||!i)&&h(void 0)},_errorSteps:()=>{n=!1}}),_(void 0))}function ue(g){if(o=!0,s=g,i){let R=we([s,d]),P=k(e,R);h(P)}return y}function L(g){if(i=!0,d=g,o){let R=we([s,d]),P=k(e,R);h(P)}return y}function O(){}return c=Qt(O,v,ue),b=Qt(O,v,L),ct(r._closedPromise,g=>{Y(c._readableStreamController,g),Y(b._readableStreamController,g),(!o||!i)&&h(void 0)}),[c,b]}function _a(e){let t=be(e),r=!1,n=!1,a=!1,o=!1,i=!1,s,d,c,b,h,y=S(u=>{h=u});function v(u){ct(u._closedPromise,f=>{u===t&&(q(c._readableStreamController,f),q(b._readableStreamController,f),(!o||!i)&&h(void 0))})}function ue(){re(t)&&(I(t),t=be(e),v(t)),Re(t,{_chunkSteps:f=>{Be(()=>{n=!1,a=!1;let p=f,C=f;if(!o&&!i)try{C=br(f)}catch(le){q(c._readableStreamController,le),q(b._readableStreamController,le),h(k(e,le));return}o||$e(c._readableStreamController,p),i||$e(b._readableStreamController,C),r=!1,n?O():a&&g()})},_closeSteps:()=>{r=!1,o||Ce(c._readableStreamController),i||Ce(b._readableStreamController),c._readableStreamController._pendingPullIntos.length>0&&Me(c._readableStreamController,0),b._readableStreamController._pendingPullIntos.length>0&&Me(b._readableStreamController,0),(!o||!i)&&h(void 0)},_errorSteps:()=>{r=!1}})}function L(u,f){$(t)&&(I(t),t=Cr(e),v(t));let p=f?b:c,C=f?c:b;vr(t,u,{_chunkSteps:de=>{Be(()=>{n=!1,a=!1;let fe=f?i:o;if(f?o:i)fe||Ne(p._readableStreamController,de);else{let Yt;try{Yt=br(de)}catch(ut){q(p._readableStreamController,ut),q(C._readableStreamController,ut),h(k(e,ut));return}fe||Ne(p._readableStreamController,de),$e(C._readableStreamController,Yt)}r=!1,n?O():a&&g()})},_closeSteps:de=>{r=!1;let fe=f?i:o,Ae=f?o:i;fe||Ce(p._readableStreamController),Ae||Ce(C._readableStreamController),de!==void 0&&(fe||Ne(p._readableStreamController,de),!Ae&&C._readableStreamController._pendingPullIntos.length>0&&Me(C._readableStreamController,0)),(!fe||!Ae)&&h(void 0)},_errorSteps:()=>{r=!1}})}function O(){if(r)return n=!0,_(void 0);r=!0;let u=Wt(c._readableStreamController);return u===null?ue():L(u._view,!1),_(void 0)}function g(){if(r)return a=!0,_(void 0);r=!0;let u=Wt(b._readableStreamController);return u===null?ue():L(u._view,!0),_(void 0)}function R(u){if(o=!0,s=u,i){let f=we([s,d]),p=k(e,f);h(p)}return y}function P(u){if(i=!0,d=u,o){let f=we([s,d]),p=k(e,f);h(p)}return y}function j(){}return c=Gr(j,O,R),b=Gr(j,g,P),v(t),[c,b]}function pa(e,t){F(e,t);let r=e,n=r==null?void 0:r.autoAllocateChunkSize,a=r==null?void 0:r.cancel,o=r==null?void 0:r.pull,i=r==null?void 0:r.start,s=r==null?void 0:r.type;return{autoAllocateChunkSize:n===void 0?void 0:nr(n,`${t} has member 'autoAllocateChunkSize' that`),cancel:a===void 0?void 0:ya(a,r,`${t} has member 'cancel' that`),pull:o===void 0?void 0:Sa(o,r,`${t} has member 'pull' that`),start:i===void 0?void 0:ga(i,r,`${t} has member 'start' that`),type:s===void 0?void 0:Ra(s,`${t} has member 'type' that`)}}function ya(e,t,r){return W(e,r),n=>Z(e,t,[n])}function Sa(e,t,r){return W(e,r),n=>Z(e,t,[n])}function ga(e,t,r){return W(e,r),n=>Oe(e,t,[n])}function Ra(e,t){if(e=`${e}`,e!=="bytes")throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamType`);return e}function wa(e,t){F(e,t);let r=e==null?void 0:e.mode;return{mode:r===void 0?void 0:Ca(r,`${t} has member 'mode' that`)}}function Ca(e,t){if(e=`${e}`,e!=="byob")throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);return e}function Pa(e,t){F(e,t);let r=e==null?void 0:e.preventCancel;return{preventCancel:Boolean(r)}}function Vr(e,t){F(e,t);let r=e==null?void 0:e.preventAbort,n=e==null?void 0:e.preventCancel,a=e==null?void 0:e.preventClose,o=e==null?void 0:e.signal;return o!==void 0&&Ta(o,`${t} has member 'signal' that`),{preventAbort:Boolean(r),preventCancel:Boolean(n),preventClose:Boolean(a),signal:o}}function Ta(e,t){if(!Fn(e))throw new TypeError(`${t} is not an AbortSignal.`)}function va(e,t){F(e,t);let r=e==null?void 0:e.readable;yt(r,"readable","ReadableWritablePair"),gt(r,`${t} has member 'readable' that`);let n=e==null?void 0:e.writable;return yt(n,"writable","ReadableWritablePair"),Er(n,`${t} has member 'writable' that`),{readable:r,writable:n}}var A=class{constructor(t={},r={}){t===void 0?t=null:tr(t,"First parameter");let n=He(r,"Second parameter"),a=pa(t,"First parameter");if(Ut(this),a.type==="bytes"){if(n.size!==void 0)throw new RangeError("The strategy for a byte stream cannot have a size function");let o=Te(n,0);Wn(this,a,o)}else{let o=Ue(n),i=Te(n,1);ba(this,a,i,o)}}get locked(){if(!V(this))throw ie("locked");return G(this)}cancel(t=void 0){return V(this)?G(this)?l(new TypeError("Cannot cancel a stream that already has a reader")):k(this,t):l(ie("cancel"))}getReader(t=void 0){if(!V(this))throw ie("getReader");return wa(t,"First parameter").mode===void 0?be(this):Cr(this)}pipeThrough(t,r={}){if(!V(this))throw ie("pipeThrough");D(t,1,"pipeThrough");let n=va(t,"First parameter"),a=Vr(r,"Second parameter");if(G(this))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");if(me(n.writable))throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");let o=Ur(this,n.writable,a.preventClose,a.preventAbort,a.preventCancel,a.signal);return ge(o),n.readable}pipeTo(t,r={}){if(!V(this))return l(ie("pipeTo"));if(t===void 0)return l("Parameter 1 is required in 'pipeTo'.");if(!he(t))return l(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));let n;try{n=Vr(r,"Second parameter")}catch(a){return l(a)}return G(this)?l(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")):me(t)?l(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")):Ur(this,t,n.preventClose,n.preventAbort,n.preventCancel,n.signal)}tee(){if(!V(this))throw ie("tee");let t=ha(this);return we(t)}values(t=void 0){if(!V(this))throw ie("values");let r=Pa(t,"First parameter");return Rn(this,r.preventCancel)}};Object.defineProperties(A.prototype,{cancel:{enumerable:!0},getReader:{enumerable:!0},pipeThrough:{enumerable:!0},pipeTo:{enumerable:!0},tee:{enumerable:!0},values:{enumerable:!0},locked:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(A.prototype,m.toStringTag,{value:"ReadableStream",configurable:!0}),typeof m.asyncIterator=="symbol"&&Object.defineProperty(A.prototype,m.asyncIterator,{value:A.prototype.values,writable:!0,configurable:!0});function Qt(e,t,r,n=1,a=()=>1){let o=Object.create(A.prototype);Ut(o);let i=Object.create(H.prototype);return Yr(o,i,e,t,r,n,a),o}function Gr(e,t,r){let n=Object.create(A.prototype);Ut(n);let a=Object.create(N.prototype);return wr(n,a,e,t,r,0,void 0),n}function Ut(e){e._state="readable",e._reader=void 0,e._storedError=void 0,e._disturbed=!1}function V(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_readableStreamController")?!1:e instanceof A}function G(e){return e._reader!==void 0}function k(e,t){if(e._disturbed=!0,e._state==="closed")return _(void 0);if(e._state==="errored")return l(e._storedError);qe(e);let r=e._reader;r!==void 0&&re(r)&&(r._readIntoRequests.forEach(a=>{a._closeSteps(void 0)}),r._readIntoRequests=new T);let n=e._readableStreamController[_t](t);return X(n,lt)}function qe(e){e._state="closed";let t=e._reader;t!==void 0&&(Jt(t),$(t)&&(t._readRequests.forEach(r=>{r._closeSteps()}),t._readRequests=new T))}function Xr(e,t){e._state="errored",e._storedError=t;let r=e._reader;r!==void 0&&(mt(r,t),$(r)?(r._readRequests.forEach(n=>{n._errorSteps(t)}),r._readRequests=new T):(r._readIntoRequests.forEach(n=>{n._errorSteps(t)}),r._readIntoRequests=new T))}function ie(e){return new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`)}function Zr(e,t){F(e,t);let r=e==null?void 0:e.highWaterMark;return yt(r,"highWaterMark","QueuingStrategyInit"),{highWaterMark:St(r)}}var Jr=e=>e.byteLength;try{Object.defineProperty(Jr,"name",{value:"size",configurable:!0})}catch{}var pe=class{constructor(t){D(t,1,"ByteLengthQueuingStrategy"),t=Zr(t,"First parameter"),this._byteLengthQueuingStrategyHighWaterMark=t.highWaterMark}get highWaterMark(){if(!xr(this))throw Kr("highWaterMark");return this._byteLengthQueuingStrategyHighWaterMark}get size(){if(!xr(this))throw Kr("size");return Jr}};Object.defineProperties(pe.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(pe.prototype,m.toStringTag,{value:"ByteLengthQueuingStrategy",configurable:!0});function Kr(e){return new TypeError(`ByteLengthQueuingStrategy.prototype.${e} can only be used on a ByteLengthQueuingStrategy`)}function xr(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_byteLengthQueuingStrategyHighWaterMark")?!1:e instanceof pe}var en=()=>1;try{Object.defineProperty(en,"name",{value:"size",configurable:!0})}catch{}var ye=class{constructor(t){D(t,1,"CountQueuingStrategy"),t=Zr(t,"First parameter"),this._countQueuingStrategyHighWaterMark=t.highWaterMark}get highWaterMark(){if(!rn(this))throw tn("highWaterMark");return this._countQueuingStrategyHighWaterMark}get size(){if(!rn(this))throw tn("size");return en}};Object.defineProperties(ye.prototype,{highWaterMark:{enumerable:!0},size:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(ye.prototype,m.toStringTag,{value:"CountQueuingStrategy",configurable:!0});function tn(e){return new TypeError(`CountQueuingStrategy.prototype.${e} can only be used on a CountQueuingStrategy`)}function rn(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_countQueuingStrategyHighWaterMark")?!1:e instanceof ye}function Ea(e,t){F(e,t);let r=e==null?void 0:e.flush,n=e==null?void 0:e.readableType,a=e==null?void 0:e.start,o=e==null?void 0:e.transform,i=e==null?void 0:e.writableType;return{flush:r===void 0?void 0:Wa(r,e,`${t} has member 'flush' that`),readableType:n,start:a===void 0?void 0:qa(a,e,`${t} has member 'start' that`),transform:o===void 0?void 0:Aa(o,e,`${t} has member 'transform' that`),writableType:i}}function Wa(e,t,r){return W(e,r),n=>Z(e,t,[n])}function qa(e,t,r){return W(e,r),n=>Oe(e,t,[n])}function Aa(e,t,r){return W(e,r),(n,a)=>Z(e,t,[n,a])}var Se=class{constructor(t={},r={},n={}){t===void 0&&(t=null);let a=He(r,"Second parameter"),o=He(n,"Third parameter"),i=Ea(t,"First parameter");if(i.readableType!==void 0)throw new RangeError("Invalid readableType specified");if(i.writableType!==void 0)throw new RangeError("Invalid writableType specified");let s=Te(o,0),d=Ue(o),c=Te(a,1),b=Ue(a),h,y=S(v=>{h=v});ka(this,y,c,b,s,d),Oa(this,i),i.start!==void 0?h(i.start(this._transformStreamController)):h(void 0)}get readable(){if(!nn(this))throw un("readable");return this._readable}get writable(){if(!nn(this))throw un("writable");return this._writable}};Object.defineProperties(Se.prototype,{readable:{enumerable:!0},writable:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(Se.prototype,m.toStringTag,{value:"TransformStream",configurable:!0});function ka(e,t,r,n,a,o){function i(){return t}function s(y){return Ia(e,y)}function d(y){return Fa(e,y)}function c(){return Da(e)}e._writable=$n(i,s,c,d,r,n);function b(){return La(e)}function h(y){return at(e,y),_(void 0)}e._readable=Qt(i,b,h,a,o),e._backpressure=void 0,e._backpressureChangePromise=void 0,e._backpressureChangePromise_resolve=void 0,ot(e,!0),e._transformStreamController=void 0}function nn(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_transformStreamController")?!1:e instanceof Se}function nt(e,t){Y(e._readable._readableStreamController,t),at(e,t)}function at(e,t){an(e._transformStreamController),It(e._writable._writableStreamController,t),e._backpressure&&ot(e,!1)}function ot(e,t){e._backpressureChangePromise!==void 0&&e._backpressureChangePromise_resolve(),e._backpressureChangePromise=S(r=>{e._backpressureChangePromise_resolve=r}),e._backpressure=t}var se=class{constructor(){throw new TypeError("Illegal constructor")}get desiredSize(){if(!it(this))throw st("desiredSize");let t=this._controlledTransformStream._readable._readableStreamController;return Nt(t)}enqueue(t=void 0){if(!it(this))throw st("enqueue");on(this,t)}error(t=void 0){if(!it(this))throw st("error");ja(this,t)}terminate(){if(!it(this))throw st("terminate");za(this)}};Object.defineProperties(se.prototype,{enqueue:{enumerable:!0},error:{enumerable:!0},terminate:{enumerable:!0},desiredSize:{enumerable:!0}}),typeof m.toStringTag=="symbol"&&Object.defineProperty(se.prototype,m.toStringTag,{value:"TransformStreamDefaultController",configurable:!0});function it(e){return!w(e)||!Object.prototype.hasOwnProperty.call(e,"_controlledTransformStream")?!1:e instanceof se}function Ba(e,t,r,n){t._controlledTransformStream=e,e._transformStreamController=t,t._transformAlgorithm=r,t._flushAlgorithm=n}function Oa(e,t){let r=Object.create(se.prototype),n=o=>{try{return on(r,o),_(void 0)}catch(i){return l(i)}},a=()=>_(void 0);t.transform!==void 0&&(n=o=>t.transform(o,r)),t.flush!==void 0&&(a=()=>t.flush(r)),Ba(e,r,n,a)}function an(e){e._transformAlgorithm=void 0,e._flushAlgorithm=void 0}function on(e,t){let r=e._controlledTransformStream,n=r._readable._readableStreamController;if(!_e(n))throw new TypeError("Readable side is not in a state that permits enqueue");try{tt(n,t)}catch(o){throw at(r,o),r._readable._storedError}ca(n)!==r._backpressure&&ot(r,!0)}function ja(e,t){nt(e._controlledTransformStream,t)}function sn(e,t){let r=e._transformAlgorithm(t);return X(r,void 0,n=>{throw nt(e._controlledTransformStream,n),n})}function za(e){let t=e._controlledTransformStream,r=t._readable._readableStreamController;We(r);let n=new TypeError("TransformStream terminated");at(t,n)}function Ia(e,t){let r=e._transformStreamController;if(e._backpressure){let n=e._backpressureChangePromise;return X(n,()=>{let a=e._writable;if(a._state==="erroring")throw a._storedError;return sn(r,t)})}return sn(r,t)}function Fa(e,t){return nt(e,t),_(void 0)}function Da(e){let t=e._readable,r=e._transformStreamController,n=r._flushAlgorithm();return an(r),X(n,()=>{if(t._state==="errored")throw t._storedError;We(t._readableStreamController)},a=>{throw nt(e,a),t._storedError})}function La(e){return ot(e,!1),e._backpressureChangePromise}function st(e){return new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`)}function un(e){return new TypeError(`TransformStream.prototype.${e} can only be used on a TransformStream`)}var Ht={ReadableStream:A,ReadableStreamDefaultController:H,ReadableByteStreamController:N,ReadableStreamBYOBRequest:K,ReadableStreamDefaultReader:J,ReadableStreamBYOBReader:te,WritableStream:Q,WritableStreamDefaultController:U,WritableStreamDefaultWriter:ne,ByteLengthQueuingStrategy:pe,CountQueuingStrategy:ye,TransformStream:Se,TransformStreamDefaultController:se};if(typeof ke!="undefined")for(let e in Ht)Object.prototype.hasOwnProperty.call(Ht,e)&&Object.defineProperty(ke,e,{value:Ht[e],writable:!0,configurable:!0});globalThis.ReadableStream=A,globalThis.WritableStream=Q;})(); diff --git a/packages/graalvm/src/main/resources/META-INF/elide/embedded/runtime/js/runtime.json.gz b/packages/graalvm/src/main/resources/META-INF/elide/embedded/runtime/js/runtime.json.gz index d669541054c75477bda21c92b5a64cee8df011b4..1037df5eb7f70128bba0209144a371448e92b14e 100644 GIT binary patch delta 63 zcmV-F0KosA0k8oFABzYG;m5L(2YN3kK{2)JqM6E&zDo5h?5d007})7m)w} delta 45 zcmdnMIFFHCzMF%CpJ(Gl_9|J2Y5rPgy%}e<() { // build a source chunk for the test script val src = Source.newBuilder( - "js", + ElideJavaScriptLanguage.ID, // trim initial empty line if (script[0] == '\n') script.drop(1) else script, if (esm) "test.mjs" else "test.js", diff --git a/packages/graalvm/src/test/kotlin/elide/runtime/intrinsics/js/JsGlobalsTest.kt b/packages/graalvm/src/test/kotlin/elide/runtime/intrinsics/js/JsGlobalsTest.kt index e70b9b73c..ba191bfbf 100644 --- a/packages/graalvm/src/test/kotlin/elide/runtime/intrinsics/js/JsGlobalsTest.kt +++ b/packages/graalvm/src/test/kotlin/elide/runtime/intrinsics/js/JsGlobalsTest.kt @@ -12,6 +12,7 @@ */ package elide.runtime.intrinsics.js +import com.oracle.truffle.js.lang.JavaScriptLanguage import org.graalvm.polyglot.Context import org.graalvm.polyglot.Source import org.junit.jupiter.api.Assumptions @@ -25,9 +26,9 @@ import elide.runtime.core.DelicateElideApi import elide.runtime.core.PolyglotEngine import elide.runtime.core.PolyglotEngineConfiguration.HostAccess.ALLOW_ALL import elide.runtime.gvm.GraalVMGuest -import elide.runtime.gvm.GuestLanguage import elide.runtime.gvm.internals.IntrinsicsManager import elide.runtime.gvm.internals.intrinsics.js.AbstractJsIntrinsic +import elide.runtime.gvm.internals.js.ELIDE_JS_LANGUAGE_ID import elide.runtime.gvm.js.AbstractJsTest import elide.runtime.gvm.js.JsSymbol.JsSymbols.asPublicJsSymbol import elide.runtime.intrinsics.GuestIntrinsic.MutableIntrinsicBindings @@ -47,7 +48,7 @@ private const val ENABLE_SUPPRESSIONS = true "Failed to locate JS polyfills" }.readText() - private val polyfillsSrc = Source.create("js", polyfillsContent) + private val polyfillsSrc = Source.create(ELIDE_JS_LANGUAGE_ID, polyfillsContent) @Inject private lateinit var intrinsics: IntrinsicsManager @@ -360,7 +361,7 @@ private const val ENABLE_SUPPRESSIONS = true } } else withFreshContext { if (ENABLE_POLYFILLS) eval(polyfillsSrc) - eval(Source.create("js", block.invoke())).let { value -> + eval(Source.create(ELIDE_JS_LANGUAGE_ID, block.invoke())).let { value -> assertNotNull(value, "should get value from guest execution") assertFalse(value.isNull, "value should not be `null`") assertFalse(value.isBoolean && !value.asBoolean(), "value should not be `false`") @@ -382,7 +383,7 @@ private const val ENABLE_SUPPRESSIONS = true DynamicTest.dynamicTest(polyfilledName) { withFreshContext { eval(polyfillsSrc).let { value -> - val bindings = value.context.getBindings("js") + val bindings = value.context.getBindings(JavaScriptLanguage.ID) val obj = assertNotNull( bindings.getMember(polyfilledName), "global symbol '$polyfilledName' is missing from polyfilled bindings", diff --git a/runtime b/runtime index 3928b556e..5f210749f 160000 --- a/runtime +++ b/runtime @@ -1 +1 @@ -Subproject commit 3928b556ebf4d6c8c6f2bd1c93856dd8bc12a413 +Subproject commit 5f210749fffc96a5b3d1e42e4a6992ddecd8204d