@next2d/builder 0.1.7 → 0.1.10

package/templates/xbox/src/platform/StbTextRasterizer.cpp

@@ -0,0 +1,324 @@
+#include "StbTextRasterizer.h"
+
+#define STB_TRUETYPE_IMPLEMENTATION
+#define STBTT_STATIC
+#include "third_party/stb_truetype.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <cstring>
+
+namespace next2d::stbtext {
+
+namespace {
+
+struct Font {
+    std::string name_lower;      // 登録名 (小文字)
+    bool bold = false;           // 名前に "bold" を含むか
+    std::vector<uint8_t> data;   // TTF/OTF 本体 (fontinfo が参照し続けるため保持)
+    stbtt_fontinfo info = {};
+};
+
+// 登録フォント。ゲーム起動時に main が登録し、以後は読み取りのみ
+// (worker も協調シングルスレッドなので排他は不要)。
+std::vector<Font>& Fonts()
+{
+    static std::vector<Font> fonts;
+    return fonts;
+}
+
+std::string ToLower(std::string s)
+{
+    std::transform(s.begin(), s.end(), s.begin(),
+                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+    return s;
+}
+
+// CSS font 文字列から px サイズ / bold / ファミリ名リストを取り出す。
+// 例: "bold 24px 'Noto Sans JP', sans-serif"
+struct CssFont {
+    double px = 16.0;
+    bool bold = false;
+    std::vector<std::string> families;   // 小文字・引用符除去済み
+};
+
+CssFont ParseCssFont(const std::string& css)
+{
+    CssFont out;
+    const std::string lower = ToLower(css);
+
+    if (lower.find("bold") != std::string::npos) {
+        out.bold = true;
+    } else {
+        // 数値ウェイト (600 以上を bold 扱い)。"NNNpx" と混同しないよう
+        // 独立トークンのみ見る。
+        size_t pos = 0;
+        while (pos < lower.size()) {
+            const size_t start = lower.find_first_not_of(" \t", pos);
+            if (start == std::string::npos) break;
+            size_t end = lower.find_first_of(" \t", start);
+            if (end == std::string::npos) end = lower.size();
+            const std::string token = lower.substr(start, end - start);
+            char* endp = nullptr;
+            const long w = std::strtol(token.c_str(), &endp, 10);
+            if (endp && *endp == '\0' && w >= 600 && w <= 1000) {
+                out.bold = true;
+            }
+            pos = end;
+        }
+    }
+
+    // "NNpx" (小数許容)
+    const size_t px_pos = lower.find("px");
+    if (px_pos != std::string::npos) {
+        size_t num_start = px_pos;
+        while (num_start > 0 &&
+               (std::isdigit(static_cast<unsigned char>(lower[num_start - 1])) ||
+                lower[num_start - 1] == '.')) {
+            --num_start;
+        }
+        if (num_start < px_pos) {
+            out.px = std::strtod(lower.substr(num_start, px_pos - num_start).c_str(), nullptr);
+        }
+        if (out.px <= 0) {
+            out.px = 16.0;
+        }
+
+        // px の後ろがファミリリスト (カンマ区切り、引用符除去)
+        size_t fam_start = lower.find_first_of(" \t", px_pos);
+        if (fam_start != std::string::npos) {
+            std::string families = lower.substr(fam_start + 1);
+            size_t pos = 0;
+            while (pos <= families.size()) {
+                size_t comma = families.find(',', pos);
+                if (comma == std::string::npos) comma = families.size();
+                std::string fam = families.substr(pos, comma - pos);
+                // trim + 引用符除去
+                const auto is_trim = [](char c) {
+                    return c == ' ' || c == '\t' || c == '\'' || c == '"';
+                };
+                while (!fam.empty() && is_trim(fam.front())) fam.erase(fam.begin());
+                while (!fam.empty() && is_trim(fam.back()))  fam.pop_back();
+                if (!fam.empty()) {
+                    out.families.push_back(fam);
+                }
+                pos = comma + 1;
+            }
+        }
+    }
+    return out;
+}
+
+// wstring -> Unicode コードポイント列。
+// Windows は wchar_t=UTF-16 (サロゲートペア復号)、他は UTF-32。
+std::vector<uint32_t> ToCodepoints(const std::wstring& text)
+{
+    std::vector<uint32_t> cps;
+    cps.reserve(text.size());
+    if (sizeof(wchar_t) == 2) {
+        for (size_t i = 0; i < text.size(); ++i) {
+            const uint32_t c = static_cast<uint16_t>(text[i]);
+            if (c >= 0xD800 && c <= 0xDBFF && i + 1 < text.size()) {
+                const uint32_t lo = static_cast<uint16_t>(text[i + 1]);
+                if (lo >= 0xDC00 && lo <= 0xDFFF) {
+                    cps.push_back(0x10000 + ((c - 0xD800) << 10) + (lo - 0xDC00));
+                    ++i;
+                    continue;
+                }
+            }
+            cps.push_back(c);
+        }
+    } else {
+        for (wchar_t c : text) {
+            cps.push_back(static_cast<uint32_t>(c));
+        }
+    }
+    return cps;
+}
+
+// css のファミリ指定と bold から最適な登録フォントを選ぶ。
+// 優先: ファミリ一致 + bold 一致 > ファミリ一致 > bold 一致 > 先頭。
+const Font* SelectFont(const CssFont& css)
+{
+    const auto& fonts = Fonts();
+    if (fonts.empty()) {
+        return nullptr;
+    }
+    const Font* family_match = nullptr;
+    for (const auto& fam : css.families) {
+        for (const auto& f : fonts) {
+            if (f.name_lower.find(fam) == std::string::npos &&
+                fam.find(f.name_lower) == std::string::npos) {
+                continue;
+            }
+            if (f.bold == css.bold) {
+                return &f;   // ファミリ+bold 完全一致
+            }
+            if (!family_match) {
+                family_match = &f;
+            }
+        }
+    }
+    if (family_match) {
+        return family_match;
+    }
+    for (const auto& f : fonts) {
+        if (f.bold == css.bold) {
+            return &f;
+        }
+    }
+    return &fonts.front();
+}
+
+// 計測とラスタライズで共有するレイアウト計算。
+struct Layout {
+    const Font* font = nullptr;
+    float scale = 0;
+    int ascent = 0, descent = 0;   // フォント単位
+    double width = 0;              // px
+    std::vector<uint32_t> cps;
+};
+
+bool ComputeLayout(const std::string& css_font, const std::wstring& text, Layout& lo)
+{
+    const CssFont css = ParseCssFont(css_font);
+    lo.font = SelectFont(css);
+    if (!lo.font) {
+        return false;
+    }
+    lo.scale = stbtt_ScaleForPixelHeight(&lo.font->info, static_cast<float>(css.px));
+    int line_gap = 0;
+    stbtt_GetFontVMetrics(&lo.font->info, &lo.ascent, &lo.descent, &line_gap);
+    lo.cps = ToCodepoints(text);
+
+    double x = 0;
+    for (size_t i = 0; i < lo.cps.size(); ++i) {
+        int advance = 0, lsb = 0;
+        stbtt_GetCodepointHMetrics(&lo.font->info, static_cast<int>(lo.cps[i]), &advance, &lsb);
+        x += advance * lo.scale;
+        if (i + 1 < lo.cps.size()) {
+            x += stbtt_GetCodepointKernAdvance(
+                     &lo.font->info,
+                     static_cast<int>(lo.cps[i]),
+                     static_cast<int>(lo.cps[i + 1])) * lo.scale;
+        }
+    }
+    lo.width = x;
+    return true;
+}
+
+} // namespace
+
+bool RegisterFont(const std::string& name, std::vector<uint8_t> data)
+{
+    if (data.empty()) {
+        return false;
+    }
+    Font font;
+    font.name_lower = ToLower(name);
+    font.bold = font.name_lower.find("bold") != std::string::npos;
+    font.data = std::move(data);
+    const int offset = stbtt_GetFontOffsetForIndex(font.data.data(), 0);
+    if (offset < 0 || !stbtt_InitFont(&font.info, font.data.data(), offset)) {
+        return false;
+    }
+    Fonts().push_back(std::move(font));
+    return true;
+}
+
+bool HasFonts()
+{
+    return !Fonts().empty();
+}
+
+bool MeasureText(const std::string& css_font, const std::wstring& text,
+                 TextMetricsInfo& out)
+{
+    Layout lo;
+    if (!ComputeLayout(css_font, text, lo)) {
+        return false;
+    }
+    out.width   = lo.width;
+    out.ascent  = lo.ascent * lo.scale;
+    out.descent = -lo.descent * lo.scale;   // stbtt の descent は負値
+    return true;
+}
+
+bool RasterizeText(const std::string& css_font, const std::wstring& text,
+                   uint8_t r, uint8_t g, uint8_t b, TextBitmap& out)
+{
+    if (text.empty()) {
+        return false;   // DirectWrite 実装と同じ契約 (空文字は false)
+    }
+    Layout lo;
+    if (!ComputeLayout(css_font, text, lo)) {
+        return false;
+    }
+
+    const double ascent_px  = lo.ascent * lo.scale;
+    const double descent_px = -lo.descent * lo.scale;
+    const int width  = std::max(1, static_cast<int>(std::ceil(lo.width)) + 2);
+    const int height = std::max(1, static_cast<int>(std::ceil(ascent_px + descent_px)) + 2);
+    const int baseline = static_cast<int>(std::ceil(ascent_px)) + 1;
+
+    // 8bit カバレッジへ全グリフを合成してから RGBA 化する
+    std::vector<uint8_t> coverage(static_cast<size_t>(width) * height, 0);
+    double pen_x = 1.0;
+    for (size_t i = 0; i < lo.cps.size(); ++i) {
+        const int cp = static_cast<int>(lo.cps[i]);
+        int advance = 0, lsb = 0;
+        stbtt_GetCodepointHMetrics(&lo.font->info, cp, &advance, &lsb);
+
+        int x0 = 0, y0 = 0, x1 = 0, y1 = 0;
+        const float shift_x =
+            static_cast<float>(pen_x + lsb * lo.scale - std::floor(pen_x + lsb * lo.scale));
+        stbtt_GetCodepointBitmapBoxSubpixel(
+            &lo.font->info, cp, lo.scale, lo.scale, shift_x, 0, &x0, &y0, &x1, &y1);
+
+        const int gw = x1 - x0;
+        const int gh = y1 - y0;
+        if (gw > 0 && gh > 0) {
+            std::vector<uint8_t> glyph(static_cast<size_t>(gw) * gh);
+            stbtt_MakeCodepointBitmapSubpixel(
+                &lo.font->info, glyph.data(), gw, gh, gw,
+                lo.scale, lo.scale, shift_x, 0, cp);
+
+            const int dst_x = static_cast<int>(std::floor(pen_x + lsb * lo.scale));
+            const int dst_y = baseline + y0;
+            for (int yy = 0; yy < gh; ++yy) {
+                const int py = dst_y + yy;
+                if (py < 0 || py >= height) continue;
+                for (int xx = 0; xx < gw; ++xx) {
+                    const int px = dst_x + xx;
+                    if (px < 0 || px >= width) continue;
+                    uint8_t& dst = coverage[static_cast<size_t>(py) * width + px];
+                    dst = std::max(dst, glyph[static_cast<size_t>(yy) * gw + xx]);
+                }
+            }
+        }
+
+        pen_x += advance * lo.scale;
+        if (i + 1 < lo.cps.size()) {
+            pen_x += stbtt_GetCodepointKernAdvance(
+                         &lo.font->info, cp, static_cast<int>(lo.cps[i + 1])) * lo.scale;
+        }
+    }
+
+    out.width = width;
+    out.height = height;
+    out.baseline = baseline;
+    out.rgba.assign(static_cast<size_t>(width) * height * 4, 0);
+    for (size_t i = 0; i < coverage.size(); ++i) {
+        const uint8_t a = coverage[i];
+        if (!a) continue;
+        uint8_t* dst = &out.rgba[i * 4];
+        dst[0] = r;
+        dst[1] = g;
+        dst[2] = b;
+        dst[3] = a;   // straight alpha (TextBitmap の契約)
+    }
+    return true;
+}
+
+} // namespace next2d::stbtext

package/templates/xbox/src/platform/StbTextRasterizer.h

@@ -0,0 +1,37 @@
+// stb_truetype によるテキスト計測/ラスタライズ (全プラットフォーム共通)。
+//
+// コンソール (Game Core OS) には DirectWrite が無いため、TextRasterizer.cpp の
+// コンソール分岐がこの実装へ委譲する (デスクトップは従来どおり DirectWrite)。
+// システムフォントにも依存できないため、フォントは実行時に登録する:
+//   - 埋め込み pak 内の *.ttf/*.otf (ゲーム資材。main.cpp が起動時に登録)
+//   - exe 隣接の fonts/*.ttf (開発ビルド用)
+// フォント未登録の場合は false を返し、呼び出し側 (Canvas2D) が近似値へ
+// フォールバックする (TextRasterizer.h と同じ契約)。
+//
+// 制限 (DirectWrite との差): 合字/シェーピング無し (CJK は影響なし)、
+// bold は登録フォントに bold バリアントがある場合のみ反映。
+#pragma once
+
+#include "TextRasterizer.h"   // TextBitmap / TextMetricsInfo
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace next2d::stbtext {
+
+// TTF/OTF バイト列をフォントとして登録する (name はファイル名 stem 等の識別子。
+// "bold" を含む名前は bold バリアントとして扱う)。不正なフォントは false。
+bool RegisterFont(const std::string& name, std::vector<uint8_t> data);
+
+// 登録済みフォントが 1 つ以上あるか。
+bool HasFonts();
+
+// css_font 例: "bold 24px Arial", "16px 'Noto Sans JP', sans-serif"
+bool MeasureText(const std::string& css_font, const std::wstring& text,
+                 TextMetricsInfo& out);
+
+bool RasterizeText(const std::string& css_font, const std::wstring& text,
+                   uint8_t r, uint8_t g, uint8_t b, TextBitmap& out);
+
+} // namespace next2d::stbtext

package/templates/xbox/src/platform/TextRasterizer.cpp

@@ -1,5 +1,12 @@
 #include "TextRasterizer.h"
 
+// DirectWrite / Direct2D / WIC はコンソール (Game Core OS) に存在しない
+// デスクトップ専用 API。コンソールでは false を返し、呼び出し側
+// (Canvas2D の fillText/measureText) が近似値へフォールバックする
+// (契約は TextRasterizer.h に明記済み)。
+// 実機でのテキスト描画品質は devkit 段階の課題 (stb_truetype + フォント同梱)。
+#if !NEXT2D_XBOX_CONSOLE
+
 #include "../bindings/RasterCore.h"
 
 #include <algorithm>
@@ -181,3 +188,28 @@ bool RasterizeTextWithDWrite(const std::string& css_font, const std::wstring& te
 }
 
 } // namespace next2d
+
+#else // NEXT2D_XBOX_CONSOLE
+
+// コンソール: stb_truetype 実装へ委譲する。フォントは main.cpp が起動時に
+// 埋め込み資材 (*.ttf/*.otf) から登録する。未登録なら false を返し、
+// 呼び出し側 (Canvas2D) が近似値へフォールバックする。
+#include "StbTextRasterizer.h"
+
+namespace next2d {
+
+bool MeasureTextWithDWrite(const std::string& css_font, const std::wstring& text,
+                           TextMetricsInfo& out)
+{
+    return stbtext::MeasureText(css_font, text, out);
+}
+
+bool RasterizeTextWithDWrite(const std::string& css_font, const std::wstring& text,
+                             uint8_t r, uint8_t g, uint8_t b, TextBitmap& out)
+{
+    return stbtext::RasterizeText(css_font, text, r, g, b, out);
+}
+
+} // namespace next2d
+
+#endif // !NEXT2D_XBOX_CONSOLE

package/templates/xbox/src/platform/WicDecoder.cpp

@@ -1,5 +1,10 @@
 #include "WicDecoder.h"
 
+// WIC はコンソール (Game Core OS) に存在しないデスクトップ専用 API。
+// 第一経路は ImageDecoder (stb_image) で、本ファイルはデスクトップの
+// フォールバック (TIFF/HEIF 等 stb 非対応形式) のみを担う。
+#if !NEXT2D_XBOX_CONSOLE
+
 #include <wincodec.h>
 #include <wrl/client.h>
 
@@ -61,3 +66,17 @@ bool DecodeImageWithWIC(const std::vector<uint8_t>& input, DecodedImage& out)
 }
 
 } // namespace next2d
+
+#else // NEXT2D_XBOX_CONSOLE
+
+namespace next2d {
+
+// コンソール: WIC 無し。ImageDecoder (stb_image) が全デコードを担う。
+bool DecodeImageWithWIC(const std::vector<uint8_t>&, DecodedImage&)
+{
+    return false;
+}
+
+} // namespace next2d
+
+#endif // !NEXT2D_XBOX_CONSOLE

package/templates/xbox/src/v8/CodeCache.h

@@ -0,0 +1,223 @@
+// V8 バイトコードキャッシュ。
+//
+// player+framework のバンドル (数 MB) は毎起動フルパースがかかり、jitless
+// (Ignition) では起動時間の主要因になる。初回起動時に eager コンパイルして
+// バイトコードをディスクへ保存し、2 回目以降はそれを消費してパースを省略する。
+// 生成物はデータであり動的コード生成ではないため、コンソール (JIT 禁止) でも使える。
+//
+// - 保存先: %LOCALAPPDATA%\Next2D\codecache\<hash>.v8bc
+//   (DomShims の localStorage バックエンドと同じ配置方針。環境変数が無ければ無効化)
+// - キー: スクリプト名 + ソース内容の FNV-1a。ソースが変われば別ファイルになる。
+// - V8 のバージョン/フラグ不一致は V8 自身が検出して reject する (その場で作り直す)。
+// - すべてのエラーは graceful degrade (キャッシュ無しの通常コンパイルに落ちる)。
+// - 小さいスクリプトはパースが安く I/O の方が高いため対象外 (kMinSourceSize)。
+#pragma once
+
+#include <v8.h>
+
+#include <chrono>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace next2d::codecache {
+
+// キャッシュ対象の最小ソースサイズ。bootstrap.js (十数 KB) は対象外、
+// ゲーム/player バンドル (数百 KB〜数 MB) が対象になる境界。
+inline constexpr size_t kMinSourceSize = 64 * 1024;
+
+inline const std::filesystem::path& CacheDir()
+{
+    static const std::filesystem::path dir = []() -> std::filesystem::path {
+        const char* base = std::getenv("LOCALAPPDATA");
+        if (!base || !*base) {
+            return {};
+        }
+        std::error_code ec;
+        std::filesystem::path d = std::filesystem::path(base) / "Next2D" / "codecache";
+        std::filesystem::create_directories(d, ec);
+        if (ec) {
+            return {};
+        }
+        // ゲーム更新でソースが変わるとキャッシュはファイル名ごと変わり、旧ファイルは
+        // 参照されない孤児になる。30 日アクセスの無い .v8bc を起動時に掃除する
+        // (Load が使用時に write time を touch するため実質 LRU)。
+        const auto now = std::filesystem::file_time_type::clock::now();
+        std::error_code iter_ec;
+        for (const auto& entry : std::filesystem::directory_iterator(d, iter_ec)) {
+            std::error_code e2;
+            if (entry.path().extension() != ".v8bc") {
+                continue;
+            }
+            const auto t = std::filesystem::last_write_time(entry.path(), e2);
+            if (!e2 && now - t > std::chrono::hours(24 * 30)) {
+                std::filesystem::remove(entry.path(), e2);
+            }
+        }
+        return d;
+    }();
+    return dir;
+}
+
+inline uint64_t Fnv1a(const void* data, size_t size, uint64_t hash = 1469598103934665603ull)
+{
+    const auto* p = static_cast<const unsigned char*>(data);
+    for (size_t i = 0; i < size; ++i) {
+        hash ^= p[i];
+        hash *= 1099511628211ull;
+    }
+    return hash;
+}
+
+inline std::filesystem::path CacheFileFor(const std::string& name, const std::string& source)
+{
+    const std::filesystem::path& dir = CacheDir();
+    if (dir.empty()) {
+        return {};
+    }
+    uint64_t h = Fnv1a(name.data(), name.size());
+    h = Fnv1a(source.data(), source.size(), h);
+    char buf[17] = {};
+    std::snprintf(buf, sizeof(buf), "%016llx", static_cast<unsigned long long>(h));
+    return dir / (std::string(buf) + ".v8bc");
+}
+
+inline bool Eligible(const std::string& source)
+{
+    return source.size() >= kMinSourceSize && !CacheDir().empty();
+}
+
+// キャッシュファイルを読む。戻り値の所有権は ScriptCompiler::Source が取る
+// (BufferOwned なので CachedData 破棄時に delete[] される)。無ければ nullptr。
+inline v8::ScriptCompiler::CachedData* Load(const std::string& name, const std::string& source)
+{
+    const std::filesystem::path file = CacheFileFor(name, source);
+    if (file.empty()) {
+        return nullptr;
+    }
+    std::ifstream ifs(file, std::ios::binary);
+    if (!ifs) {
+        return nullptr;
+    }
+    std::vector<char> buf(
+        (std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
+    if (buf.empty()) {
+        return nullptr;
+    }
+    // 使用時に write time を更新し、CacheDir の 30 日掃除を LRU として機能させる
+    std::error_code ec;
+    std::filesystem::last_write_time(
+        file, std::filesystem::file_time_type::clock::now(), ec);
+
+    auto* data = new uint8_t[buf.size()];
+    std::memcpy(data, buf.data(), buf.size());
+    return new v8::ScriptCompiler::CachedData(
+        data, static_cast<int>(buf.size()),
+        v8::ScriptCompiler::CachedData::BufferOwned);
+}
+
+inline void Store(const std::string& name, const std::string& source,
+                  const v8::ScriptCompiler::CachedData* data)
+{
+    if (!data || !data->data || data->length <= 0) {
+        return;
+    }
+    const std::filesystem::path file = CacheFileFor(name, source);
+    if (file.empty()) {
+        return;
+    }
+    std::ofstream ofs(file, std::ios::binary | std::ios::trunc);
+    if (ofs) {
+        ofs.write(reinterpret_cast<const char*>(data->data), data->length);
+    }
+}
+
+// classic script をキャッシュ込みでコンパイルする。
+// - キャッシュ有り: kConsumeCodeCache で消費 (V8 が reject したら作り直して保存)
+// - キャッシュ無し: kEagerCompile で全関数を一括コンパイルして保存
+//   (初回はその分遅いが、以降の起動は lazy compile も含めて丸ごと省ける)
+// - 対象外サイズ: 従来どおりの lazy コンパイル
+inline v8::MaybeLocal<v8::Script> Compile(v8::Local<v8::Context> ctx,
+                                          v8::Local<v8::String> src,
+                                          v8::ScriptOrigin& origin,
+                                          const std::string& name,
+                                          const std::string& source_str)
+{
+    if (!Eligible(source_str)) {
+        v8::ScriptCompiler::Source source(src, origin);
+        return v8::ScriptCompiler::Compile(ctx, &source);
+    }
+
+    if (v8::ScriptCompiler::CachedData* cached = Load(name, source_str)) {
+        v8::ScriptCompiler::Source source(src, origin, cached);
+        v8::Local<v8::Script> script;
+        if (!v8::ScriptCompiler::Compile(
+                ctx, &source, v8::ScriptCompiler::kConsumeCodeCache).ToLocal(&script)) {
+            return {};
+        }
+        if (source.GetCachedData() && source.GetCachedData()->rejected) {
+            std::unique_ptr<v8::ScriptCompiler::CachedData> fresh(
+                v8::ScriptCompiler::CreateCodeCache(script->GetUnboundScript()));
+            Store(name, source_str, fresh.get());
+        }
+        return script;
+    }
+
+    v8::ScriptCompiler::Source source(src, origin);
+    v8::Local<v8::Script> script;
+    if (!v8::ScriptCompiler::Compile(
+            ctx, &source, v8::ScriptCompiler::kEagerCompile).ToLocal(&script)) {
+        return {};
+    }
+    std::unique_ptr<v8::ScriptCompiler::CachedData> fresh(
+        v8::ScriptCompiler::CreateCodeCache(script->GetUnboundScript()));
+    Store(name, source_str, fresh.get());
+    return script;
+}
+
+// ES module 版。規約は Compile と同じ。
+inline v8::MaybeLocal<v8::Module> CompileModule(v8::Isolate* isolate,
+                                                v8::Local<v8::String> src,
+                                                v8::ScriptOrigin& origin,
+                                                const std::string& name,
+                                                const std::string& source_str)
+{
+    if (!Eligible(source_str)) {
+        v8::ScriptCompiler::Source source(src, origin);
+        return v8::ScriptCompiler::CompileModule(isolate, &source);
+    }
+
+    if (v8::ScriptCompiler::CachedData* cached = Load(name, source_str)) {
+        v8::ScriptCompiler::Source source(src, origin, cached);
+        v8::Local<v8::Module> module;
+        if (!v8::ScriptCompiler::CompileModule(
+                isolate, &source, v8::ScriptCompiler::kConsumeCodeCache).ToLocal(&module)) {
+            return {};
+        }
+        if (source.GetCachedData() && source.GetCachedData()->rejected) {
+            std::unique_ptr<v8::ScriptCompiler::CachedData> fresh(
+                v8::ScriptCompiler::CreateCodeCache(module->GetUnboundModuleScript()));
+            Store(name, source_str, fresh.get());
+        }
+        return module;
+    }
+
+    v8::ScriptCompiler::Source source(src, origin);
+    v8::Local<v8::Module> module;
+    if (!v8::ScriptCompiler::CompileModule(
+            isolate, &source, v8::ScriptCompiler::kEagerCompile).ToLocal(&module)) {
+        return {};
+    }
+    std::unique_ptr<v8::ScriptCompiler::CachedData> fresh(
+        v8::ScriptCompiler::CreateCodeCache(module->GetUnboundModuleScript()));
+    Store(name, source_str, fresh.get());
+    return module;
+}
+
+} // namespace next2d::codecache