@bleedingdev/modern-js-renderer-octane 0.0.0-stage → 3.9.3-ultramodern.1

package/dist/cjs/i18n/languageSync.js

@@ -0,0 +1,99 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useLatestLanguageSync: ()=>useLatestLanguageSync
+});
+const controller_namespaceObject = require("@modern-js/i18n-runtime-extensions/language-sync/controller");
+const external_octane_namespaceObject = require("octane");
+const bindingSlot = Symbol((0, external_octane_namespaceObject.hookSlots)(1));
+const callbacksSlot = Symbol((0, external_octane_namespaceObject.hookSlots)(1));
+const activationSlot = Symbol((0, external_octane_namespaceObject.hookSlots)(1));
+const requestSlot = Symbol((0, external_octane_namespaceObject.hookSlots)(1));
+const retrySlot = Symbol((0, external_octane_namespaceObject.hookSlots)(1));
+const requestCallbackSlot = Symbol((0, external_octane_namespaceObject.hookSlots)(1));
+const useLatestLanguageSync = ({ changeLanguage, commitLanguage, desiredLanguage, enabled = true, policy, readLanguage, reportFailure, target })=>{
+    const bindingRef = (0, external_octane_namespaceObject.useRef)(null, bindingSlot);
+    if (null === bindingRef.current) bindingRef.current = (0, controller_namespaceObject.createLatestLanguageSyncBinding)(policy);
+    const binding = bindingRef.current;
+    (0, external_octane_namespaceObject.useEffect)(()=>{
+        binding.updateCallbacks({
+            changeLanguage,
+            commitLanguage,
+            readLanguage,
+            reportFailure
+        });
+    }, void 0, callbacksSlot);
+    (0, external_octane_namespaceObject.useEffect)(()=>{
+        if (!enabled || !target) return;
+        binding.activate(target);
+        return ()=>binding.deactivate();
+    }, [
+        binding,
+        enabled,
+        target
+    ], activationSlot);
+    (0, external_octane_namespaceObject.useEffect)(()=>{
+        if (!enabled || !target || !desiredLanguage) return void binding.clearRequest();
+        binding.request(desiredLanguage);
+    }, [
+        binding,
+        desiredLanguage,
+        enabled,
+        target
+    ], requestSlot);
+    (0, external_octane_namespaceObject.useEffect)(()=>{
+        if (!enabled || !target || !desiredLanguage || "u" < typeof window) return;
+        const retryCurrentIntent = ()=>binding.request(desiredLanguage);
+        const retryVisibleIntent = ()=>{
+            if ('visible' === document.visibilityState) retryCurrentIntent();
+        };
+        window.addEventListener('online', retryCurrentIntent);
+        document.addEventListener('visibilitychange', retryVisibleIntent);
+        return ()=>{
+            window.removeEventListener('online', retryCurrentIntent);
+            document.removeEventListener('visibilitychange', retryVisibleIntent);
+        };
+    }, [
+        binding,
+        desiredLanguage,
+        enabled,
+        target
+    ], retrySlot);
+    return (0, external_octane_namespaceObject.useCallback)((language)=>binding.request(language), [
+        binding
+    ], requestCallbackSlot);
+};
+exports.useLatestLanguageSync = __webpack_exports__.useLatestLanguageSync;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "useLatestLanguageSync"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/i18n/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/i18n/useI18n.js

@@ -0,0 +1,110 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useI18n: ()=>useI18n
+});
+const paths_namespaceObject = require("@modern-js/i18n-runtime-extensions/paths");
+const request_language_namespaceObject = require("@modern-js/i18n-runtime-extensions/request-language");
+const external_octane_namespaceObject = require("octane");
+const external_router_js_namespaceObject = require("../router.js");
+const external_context_js_namespaceObject = require("./context.js");
+const languageSwitches = new WeakMap();
+function useI18n() {
+    const context = (0, external_octane_namespaceObject.useContext)(external_context_js_namespaceObject.I18nContext);
+    if (!context) throw new Error('[renderer-octane] useI18n() was called outside of an I18nProvider.');
+    const { instance, languages, localisedUrls, language } = context;
+    const t = (key, options)=>instance.t(key, options);
+    const router = (0, external_router_js_namespaceObject.useRouter)({
+        warn: false
+    });
+    const changeLanguage = (requested)=>{
+        let nextLanguage;
+        try {
+            nextLanguage = (0, paths_namespaceObject.configuredLanguage)(requested, languages);
+        } catch (error) {
+            return Promise.reject(error);
+        }
+        const state = languageSwitches.get(instance) ?? {
+            latest: 0,
+            queue: Promise.resolve()
+        };
+        languageSwitches.set(instance, state);
+        const generation = ++state.latest;
+        const run = state.queue.then(async ()=>{
+            if (state.latest !== generation) return;
+            const committed = instance.language;
+            const publicLanguage = ()=>router ? (0, request_language_namespaceObject.languageFromPathname)(new URL(router.state.location.publicHref, 'http://localhost').pathname, languages, router.options.basepath) : void 0;
+            const reconcile = async ()=>{
+                const language = publicLanguage() ?? committed;
+                if (instance.language !== language) await instance.changeLanguage?.(language);
+            };
+            try {
+                await instance.changeLanguage?.(nextLanguage);
+            } catch (error) {
+                await reconcile();
+                throw error;
+            }
+            if (!router) return;
+            const href = (0, paths_namespaceObject.localizePath)(router.state.location.href, nextLanguage, {
+                languages: [
+                    ...languages
+                ],
+                localisedUrls
+            });
+            try {
+                await router.navigate({
+                    to: '.',
+                    href,
+                    replace: true
+                });
+            } catch (error) {
+                await reconcile();
+                throw error;
+            }
+            if (publicLanguage() !== nextLanguage) await reconcile();
+        });
+        state.queue = run.catch(()=>{});
+        return run;
+    };
+    return {
+        t,
+        language,
+        languages,
+        instance,
+        changeLanguage
+    };
+}
+exports.useI18n = __webpack_exports__.useI18n;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "useI18n"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const OCTANE_RUNTIME_PROFILE = Object.freeze({
+    renderer: 'octane',
+    runtime: '0.7.1+ultramodern.1331985ea3b0',
+    router: '0.1.60+ultramodern.0b9f76ee3003',
+    routerCore: '1.171.15',
+    history: '1.162.0'
+});
+__webpack_require__.d(__webpack_exports__, {}, {
+    OCTANE_RUNTIME_PROFILE: OCTANE_RUNTIME_PROFILE
+});
+exports.OCTANE_RUNTIME_PROFILE = __webpack_exports__.OCTANE_RUNTIME_PROFILE;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OCTANE_RUNTIME_PROFILE"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/manifest.js

@@ -0,0 +1,167 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    OCTANE_COMPILER_VERSION: ()=>OCTANE_COMPILER_VERSION,
+    OCTANE_RUNTIME_VERSION: ()=>OCTANE_RUNTIME_VERSION,
+    compilerArtifacts: ()=>compilerArtifacts,
+    octaneModuleManifestFileName: ()=>octaneModuleManifestFileName,
+    validateOctaneModuleManifest: ()=>validateOctaneModuleManifest
+});
+const identity_namespaceObject = require("@modern-js/renderer-core/identity");
+const external_bootstrap_js_namespaceObject = require("./bootstrap.js");
+const OCTANE_RUNTIME_VERSION = '0.7.1+ultramodern.1331985ea3b0';
+const OCTANE_COMPILER_VERSION = '0.1.55';
+function octaneModuleManifestFileName(entryName) {
+    return (0, identity_namespaceObject.nativeModuleManifestFilename)('octane', entryName);
+}
+function record(value, fields) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) throw new Error('Malformed Octane compiler manifest object.');
+    if (Object.keys(value).some((key)=>!fields.includes(key))) throw new Error('Octane compiler manifest contains an unknown field.');
+    return value;
+}
+function digest(value) {
+    return 'string' == typeof value && /^[a-f\d]{64}$/u.test(value);
+}
+function nonempty(value) {
+    return 'string' == typeof value && value.trim().length > 0 && !value.includes('\0');
+}
+function assetPath(value) {
+    return nonempty(value) && value.endsWith('.js') && !value.startsWith('/') && !value.includes('\\') && !value.split('/').some((part)=>'..' === part || '.' === part || !part);
+}
+const validatedManifests = new WeakMap();
+function validateOctaneModuleManifest(value, expectedIdentity, expectedNativeHydrationBuildId) {
+    (0, external_bootstrap_js_namespaceObject.assertOctaneIdentity)(expectedIdentity);
+    const cached = value && 'object' == typeof value ? validatedManifests.get(value) : void 0;
+    const manifest = cached ?? readOctaneModuleManifest(value);
+    (0, identity_namespaceObject.readRendererIdentity)(manifest.rendererIdentity, expectedIdentity);
+    if (void 0 !== expectedNativeHydrationBuildId) {
+        (0, external_bootstrap_js_namespaceObject.assertNativeHydrationBuildId)(expectedNativeHydrationBuildId);
+        if (manifest.nativeHydrationBuildId !== expectedNativeHydrationBuildId) throw new Error('Octane native hydration build differs from the compiled client.');
+    }
+    if (!cached) {
+        validatedManifests.set(value, manifest);
+        validatedManifests.set(manifest, manifest);
+    }
+    return manifest;
+}
+function readOctaneModuleManifest(value) {
+    const manifest = record(value, [
+        'schemaVersion',
+        'renderer',
+        'runtimeVersion',
+        'compilerVersion',
+        'rendererIdentity',
+        'nativeHydrationBuildId',
+        'sourceModules',
+        'assets'
+    ]);
+    if (1 !== manifest.schemaVersion || 'octane' !== manifest.renderer || manifest.runtimeVersion !== OCTANE_RUNTIME_VERSION || manifest.compilerVersion !== OCTANE_COMPILER_VERSION) throw new Error('Octane compiler manifest ABI conflicts with the application.');
+    const rendererIdentity = (0, identity_namespaceObject.readRendererIdentity)(manifest.rendererIdentity, manifest.rendererIdentity);
+    const nativeHydrationBuildId = manifest.nativeHydrationBuildId;
+    (0, external_bootstrap_js_namespaceObject.assertNativeHydrationBuildId)(nativeHydrationBuildId);
+    if (!Array.isArray(manifest.assets) || !manifest.assets.length) throw new Error('Octane compiler manifest has no emitted JavaScript closure.');
+    const assetNames = new Set();
+    const assets = manifest.assets.map((value)=>{
+        const asset = record(value, [
+            'file',
+            'sha256'
+        ]);
+        if (!assetPath(asset.file) || !digest(asset.sha256) || assetNames.has(asset.file)) throw new Error('Invalid Octane emitted asset digest.');
+        assetNames.add(asset.file);
+        return Object.freeze({
+            file: asset.file,
+            sha256: asset.sha256
+        });
+    });
+    if (!Array.isArray(manifest.sourceModules) || !manifest.sourceModules.length) throw new Error('Octane compiler manifest has no authenticated native sources.');
+    const resources = new Set();
+    const sourceModules = manifest.sourceModules.map((value)=>{
+        const source = record(value, [
+            'resource',
+            'canonicalId',
+            'moduleId',
+            'transformKind',
+            'emittedSourceSha256',
+            'assets'
+        ]);
+        if (!nonempty(source.resource) || source.resource.startsWith('/') || source.resource.includes('\\') || !nonempty(source.canonicalId) || !('string' == typeof source.moduleId && nonempty(source.moduleId) || 'number' == typeof source.moduleId && Number.isFinite(source.moduleId)) || !('compile' === source.transformKind || 'slots' === source.transformKind || 'client-only-stub' === source.transformKind) || !digest(source.emittedSourceSha256) || !Array.isArray(source.assets) || !source.assets.length || source.assets.some((file)=>'string' != typeof file || !assetNames.has(file)) || new Set(source.assets).size !== source.assets.length || resources.has(source.resource)) throw new Error('Invalid Octane native source-to-asset provenance.');
+        resources.add(source.resource);
+        return Object.freeze({
+            resource: source.resource,
+            canonicalId: source.canonicalId,
+            moduleId: source.moduleId,
+            transformKind: source.transformKind,
+            emittedSourceSha256: source.emittedSourceSha256,
+            assets: Object.freeze([
+                ...source.assets
+            ])
+        });
+    });
+    return Object.freeze({
+        schemaVersion: 1,
+        renderer: 'octane',
+        runtimeVersion: OCTANE_RUNTIME_VERSION,
+        compilerVersion: OCTANE_COMPILER_VERSION,
+        rendererIdentity,
+        nativeHydrationBuildId,
+        sourceModules: Object.freeze(sourceModules),
+        assets: Object.freeze(assets)
+    });
+}
+const compilerArtifacts = {
+    clientManifestFile: octaneModuleManifestFileName,
+    async validateClientManifest (value, identity, context) {
+        const hydrationBuildId = context.compilationHash ?? context.hydrationBuildId;
+        if (context.development && ('string' != typeof hydrationBuildId || !hydrationBuildId.trim())) throw new Error('Octane development snapshot has no native hydration build.');
+        const nativeManifest = validateOctaneModuleManifest(value, identity, hydrationBuildId);
+        return {
+            nativeManifest,
+            hydrationBuildId: nativeManifest.nativeHydrationBuildId
+        };
+    },
+    isMutableDevelopmentAsset (filename, entryNames) {
+        return 'octane-client-build.json' === filename || entryNames.some((entry)=>filename === octaneModuleManifestFileName(entry));
+    }
+};
+exports.OCTANE_COMPILER_VERSION = __webpack_exports__.OCTANE_COMPILER_VERSION;
+exports.OCTANE_RUNTIME_VERSION = __webpack_exports__.OCTANE_RUNTIME_VERSION;
+exports.compilerArtifacts = __webpack_exports__.compilerArtifacts;
+exports.octaneModuleManifestFileName = __webpack_exports__.octaneModuleManifestFileName;
+exports.validateOctaneModuleManifest = __webpack_exports__.validateOctaneModuleManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OCTANE_COMPILER_VERSION",
+    "OCTANE_RUNTIME_VERSION",
+    "compilerArtifacts",
+    "octaneModuleManifestFileName",
+    "validateOctaneModuleManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugin/compiler.js

@@ -0,0 +1,125 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createOctaneCompilerPlugin: ()=>createOctaneCompilerPlugin,
+    pluginSourceDirectory: ()=>pluginSourceDirectory
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const external_manifest_js_namespaceObject = require("../manifest.js");
+function pluginSourceDirectory() {
+    let directory = external_node_path_default().dirname((0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__));
+    while(true){
+        const compiler = external_node_path_default().join(directory, 'src/plugin');
+        if (external_node_fs_default().existsSync(external_node_path_default().join(directory, 'package.json')) && external_node_fs_default().existsSync(external_node_path_default().join(compiler, 'compiler-manifest.cjs'))) return compiler;
+        const parent = external_node_path_default().dirname(directory);
+        if (parent === directory) throw new Error('Cannot locate the UltraModern Octane compiler package.');
+        directory = parent;
+    }
+}
+function createOctaneCompilerPlugin(options) {
+    return {
+        name: 'ultramodern:octane:compiler',
+        setup (api) {
+            const directory = pluginSourceDirectory();
+            const require1 = (0, external_node_module_namespaceObject.createRequire)(external_node_path_default().join(directory, 'index.cjs'));
+            const { OctaneCompilerManifestPlugin } = require1('./compiler-manifest.cjs');
+            const { inferRspackEnvironment, OctaneRspackPlugin } = require1('@octanejs/rspack-plugin');
+            api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
+                    source: {
+                        include: [
+                            /[/\\]@octanejs[/\\]/u
+                        ]
+                    }
+                }));
+            api.modifyRspackConfig((config, { environment: rsbuildEnvironment })=>{
+                const environment = rsbuildEnvironment.name === options.workerEnvironmentName ? 'server' : inferRspackEnvironment(config.target);
+                config.resolve ??= {};
+                const extensions = (config.resolve.extensions ?? []).filter((extension)=>'.tsrx' !== extension);
+                extensions.splice(Math.max(extensions.indexOf('.ts'), extensions.indexOf('.tsx')) + 1, 0, '.tsrx');
+                config.resolve.extensions = extensions;
+                config.plugins ??= [];
+                config.plugins.push(new OctaneRspackPlugin({
+                    root: api.context.rootPath,
+                    environment,
+                    transpile: false
+                }));
+                config.plugins.push(new OctaneCompilerManifestPlugin({
+                    emitClientManifest: 'client' === environment,
+                    root: api.context.rootPath,
+                    runtimeVersion: external_manifest_js_namespaceObject.OCTANE_RUNTIME_VERSION,
+                    compilerVersion: external_manifest_js_namespaceObject.OCTANE_COMPILER_VERSION,
+                    rendererIdentities: options.rendererIdentities,
+                    manifestFilename: external_manifest_js_namespaceObject.octaneModuleManifestFileName,
+                    validateManifest: external_manifest_js_namespaceObject.validateOctaneModuleManifest
+                }));
+                config.module ??= {};
+                config.module.rules ??= [];
+                config.module.rules.push({
+                    test: /\.tsrx$/u,
+                    type: "javascript/auto",
+                    use: [
+                        {
+                            loader: 'builtin:swc-loader',
+                            options: {
+                                detectSyntax: 'auto'
+                            }
+                        }
+                    ]
+                });
+            });
+        }
+    };
+}
+exports.createOctaneCompilerPlugin = __webpack_exports__.createOctaneCompilerPlugin;
+exports.pluginSourceDirectory = __webpack_exports__.pluginSourceDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createOctaneCompilerPlugin",
+    "pluginSourceDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});