@next2d/builder 0.1.5 → 0.1.7

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

@@ -0,0 +1,40 @@
+// GamepadManager: GameInput でゲームパッド状態をポーリングし、
+// W3C Gamepad API (standard mapping) 相当のスナップショットへ変換する。
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <vector>
+
+struct IGameInput;
+
+namespace next2d {
+
+// standard mapping: 17 ボタン / 4 軸
+struct GamepadSnapshot {
+    bool connected = false;
+    std::array<float, 4> axes = {0, 0, 0, 0};        // LX, LY, RX, RY
+    std::array<float, 17> buttons = {};              // 押下量 (0.0-1.0)
+    std::array<bool, 17> pressed = {};
+    double timestamp = 0.0;
+};
+
+class GamepadManager {
+public:
+    GamepadManager();
+    ~GamepadManager();
+
+    bool Initialize();
+
+    // 毎フレーム呼ぶ。now_ms は EventLoop::Now()。
+    void Poll(double now_ms);
+
+    // 現在の全パッドスナップショット (最大 4)
+    const std::vector<GamepadSnapshot>& snapshots() const { return snapshots_; }
+
+private:
+    IGameInput* game_input_ = nullptr;
+    std::vector<GamepadSnapshot> snapshots_;
+};
+
+} // namespace next2d

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

@@ -0,0 +1,17 @@
+// 画像デコード結果の共有型。V8 に依存しないため、単体テスト
+// (tests/windows_platform_test.cpp) からも利用できる。
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+namespace next2d {
+
+// createImageBitmap / transferToImageBitmap が返す ImageBitmap の実体。
+struct DecodedImage {
+    uint32_t width = 0;
+    uint32_t height = 0;
+    std::vector<uint8_t> rgba;   // RGBA8 straight alpha
+};
+
+} // namespace next2d

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

@@ -0,0 +1,183 @@
+#include "TextRasterizer.h"
+
+#include "../bindings/RasterCore.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include <d2d1.h>
+#include <dwrite.h>
+#include <wincodec.h>
+#include <wrl/client.h>
+
+#pragma comment(lib, "d2d1.lib")
+#pragma comment(lib, "dwrite.lib")
+
+using Microsoft::WRL::ComPtr;
+
+namespace next2d {
+
+namespace {
+
+IDWriteFactory* DWrite()
+{
+    static ComPtr<IDWriteFactory> factory;
+    if (!factory) {
+        DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory),
+                            reinterpret_cast<IUnknown**>(factory.GetAddressOf()));
+    }
+    return factory.Get();
+}
+
+ID2D1Factory* D2D()
+{
+    static ComPtr<ID2D1Factory> factory;
+    if (!factory) {
+        D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, factory.GetAddressOf());
+    }
+    return factory.Get();
+}
+
+IWICImagingFactory* WIC()
+{
+    static ComPtr<IWICImagingFactory> factory;
+    if (!factory) {
+        CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+        CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER,
+                         IID_PPV_ARGS(factory.GetAddressOf()));
+    }
+    return factory.Get();
+}
+
+// CSS font 文字列から family を抽出 (px サイズは raster::FontPixelSize)。
+std::wstring FontFamily(const std::string& font)
+{
+    // 末尾のカンマ区切りの先頭ファミリを採用。無ければ Segoe UI。
+    const auto pos = font.find("px");
+    std::string rest = (pos != std::string::npos && pos + 2 < font.size())
+        ? font.substr(pos + 2) : "sans-serif";
+    // trim + 先頭ファミリ
+    size_t s = rest.find_first_not_of(" \t");
+    if (s == std::string::npos) return L"Segoe UI";
+    rest = rest.substr(s);
+    const auto comma = rest.find(',');
+    if (comma != std::string::npos) rest = rest.substr(0, comma);
+    // クォート除去
+    rest.erase(std::remove(rest.begin(), rest.end(), '\''), rest.end());
+    rest.erase(std::remove(rest.begin(), rest.end(), '"'), rest.end());
+    if (rest == "sans-serif" || rest.empty()) return L"Segoe UI";
+    if (rest == "serif") return L"Times New Roman";
+    if (rest == "monospace") return L"Consolas";
+    return std::wstring(rest.begin(), rest.end());
+}
+
+ComPtr<IDWriteTextLayout> MakeLayout(const std::string& css_font, const std::wstring& wtext)
+{
+    if (!DWrite()) return nullptr;
+    ComPtr<IDWriteTextFormat> format;
+    const bool bold = css_font.find("bold") != std::string::npos;
+    const bool italic = css_font.find("italic") != std::string::npos;
+    DWrite()->CreateTextFormat(
+        FontFamily(css_font).c_str(), nullptr,
+        bold ? DWRITE_FONT_WEIGHT_BOLD : DWRITE_FONT_WEIGHT_NORMAL,
+        italic ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL,
+        DWRITE_FONT_STRETCH_NORMAL,
+        static_cast<float>(raster::FontPixelSize(css_font)), L"en-us", &format);
+    if (!format) return nullptr;
+    ComPtr<IDWriteTextLayout> layout;
+    DWrite()->CreateTextLayout(wtext.c_str(), static_cast<UINT32>(wtext.size()),
+                               format.Get(), 100000.0f, 100000.0f, &layout);
+    return layout;
+}
+
+} // namespace
+
+bool MeasureTextWithDWrite(const std::string& css_font, const std::wstring& text,
+                           TextMetricsInfo& out)
+{
+    ComPtr<IDWriteTextLayout> layout = MakeLayout(css_font, text);
+    if (!layout) return false;
+
+    DWRITE_TEXT_METRICS tm = {};
+    layout->GetMetrics(&tm);
+    out.width = tm.widthIncludingTrailingWhitespace;
+
+    UINT32 lineCount = 0;
+    layout->GetLineMetrics(nullptr, 0, &lineCount);
+    if (lineCount > 0) {
+        std::vector<DWRITE_LINE_METRICS> lines(lineCount);
+        layout->GetLineMetrics(lines.data(), lineCount, &lineCount);
+        out.ascent = lines[0].baseline;
+        out.descent = lines[0].height - lines[0].baseline;
+    } else {
+        const double px = raster::FontPixelSize(css_font);
+        out.ascent = px * 0.8;
+        out.descent = px * 0.2;
+    }
+    return true;
+}
+
+bool RasterizeTextWithDWrite(const std::string& css_font, const std::wstring& text,
+                             uint8_t r, uint8_t g, uint8_t b, TextBitmap& out)
+{
+    if (text.empty() || !DWrite() || !D2D() || !WIC()) return false;
+    ComPtr<IDWriteTextLayout> layout = MakeLayout(css_font, text);
+    if (!layout) return false;
+
+    DWRITE_TEXT_METRICS tm = {};
+    layout->GetMetrics(&tm);
+    const int tw = std::max(1, static_cast<int>(std::ceil(tm.widthIncludingTrailingWhitespace)) + 2);
+    const int th = std::max(1, static_cast<int>(std::ceil(tm.height)) + 2);
+
+    // fillText の x,y はベースライン起点。レイアウトは左上起点なので baseline を返す。
+    out.baseline = raster::FontPixelSize(css_font) * 0.8;
+    UINT32 lineCount = 0; layout->GetLineMetrics(nullptr, 0, &lineCount);
+    if (lineCount > 0) {
+        std::vector<DWRITE_LINE_METRICS> lines(lineCount);
+        layout->GetLineMetrics(lines.data(), lineCount, &lineCount);
+        out.baseline = lines[0].baseline;
+    }
+
+    ComPtr<IWICBitmap> wic;
+    if (FAILED(WIC()->CreateBitmap(tw, th, GUID_WICPixelFormat32bppPBGRA,
+                                   WICBitmapCacheOnLoad, &wic))) return false;
+    ComPtr<ID2D1RenderTarget> rt;
+    D2D1_RENDER_TARGET_PROPERTIES props = D2D1::RenderTargetProperties(
+        D2D1_RENDER_TARGET_TYPE_SOFTWARE,
+        D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED));
+    if (FAILED(D2D()->CreateWicBitmapRenderTarget(wic.Get(), props, &rt))) return false;
+    ComPtr<ID2D1SolidColorBrush> brush;
+    rt->CreateSolidColorBrush(
+        D2D1::ColorF(r / 255.f, g / 255.f, b / 255.f, 1.0f), &brush);
+
+    rt->BeginDraw();
+    rt->Clear(D2D1::ColorF(0, 0));
+    rt->DrawTextLayout(D2D1::Point2F(0, 0), layout.Get(), brush.Get());
+    if (FAILED(rt->EndDraw())) return false;
+
+    // 読み戻し (PBGRA -> straight RGBA)
+    ComPtr<IWICBitmapLock> lock;
+    WICRect rc = {0, 0, tw, th};
+    if (FAILED(wic->Lock(&rc, WICBitmapLockRead, &lock))) return false;
+    UINT stride = 0, size = 0; BYTE* data = nullptr;
+    lock->GetStride(&stride); lock->GetDataPointer(&size, &data);
+
+    out.width = tw;
+    out.height = th;
+    out.rgba.assign(static_cast<size_t>(tw) * th * 4, 0);
+    for (int yy = 0; yy < th; ++yy) {
+        for (int xx = 0; xx < tw; ++xx) {
+            const BYTE* px = data + yy * stride + xx * 4;
+            const double a = px[3] / 255.0;
+            if (a <= 0.0) continue;
+            uint8_t* dst = &out.rgba[(static_cast<size_t>(yy) * tw + xx) * 4];
+            dst[0] = static_cast<uint8_t>(px[2] / a);  // R (un-premultiply)
+            dst[1] = static_cast<uint8_t>(px[1] / a);  // G
+            dst[2] = static_cast<uint8_t>(px[0] / a);  // B
+            dst[3] = px[3];                            // A
+        }
+    }
+    return true;
+}
+
+} // namespace next2d

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

@@ -0,0 +1,35 @@
+// DirectWrite / Direct2D によるテキストラスタライズ。V8 非依存。
+// Canvas2D.cpp (fillText/strokeText/measureText) と単体テストの両方から使う。
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace next2d {
+
+// テキストのラスタライズ結果 (straight RGBA)。
+struct TextBitmap {
+    int width = 0;
+    int height = 0;
+    double baseline = 0;             // 先頭行のベースライン位置 (上端から)
+    std::vector<uint8_t> rgba;       // width*height*4
+};
+
+// テキストのメトリクス。
+struct TextMetricsInfo {
+    double width = 0;
+    double ascent = 0;
+    double descent = 0;
+};
+
+// CSS font 文字列 ("bold 24px Arial" 等) と UTF-16 テキストからメトリクスを取得する。
+// DirectWrite が使えない場合は false (呼び出し側で近似値へフォールバック)。
+bool MeasureTextWithDWrite(const std::string& css_font, const std::wstring& text,
+                           TextMetricsInfo& out);
+
+// テキストを指定色でラスタライズする。alpha はグリフ形状から得る。
+bool RasterizeTextWithDWrite(const std::string& css_font, const std::wstring& text,
+                             uint8_t r, uint8_t g, uint8_t b, TextBitmap& out);
+
+} // namespace next2d

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

@@ -0,0 +1,63 @@
+#include "WicDecoder.h"
+
+#include <wincodec.h>
+#include <wrl/client.h>
+
+using Microsoft::WRL::ComPtr;
+
+namespace next2d {
+
+// WIC で任意フォーマットの画像を RGBA8 にデコードする。
+bool DecodeImageWithWIC(const std::vector<uint8_t>& input, DecodedImage& out)
+{
+    ComPtr<IWICImagingFactory> factory;
+    if (FAILED(CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER,
+                                IID_PPV_ARGS(&factory)))) {
+        return false;
+    }
+
+    ComPtr<IWICStream> stream;
+    if (FAILED(factory->CreateStream(&stream))) {
+        return false;
+    }
+    if (FAILED(stream->InitializeFromMemory(
+            const_cast<uint8_t*>(input.data()), static_cast<DWORD>(input.size())))) {
+        return false;
+    }
+
+    ComPtr<IWICBitmapDecoder> decoder;
+    if (FAILED(factory->CreateDecoderFromStream(
+            stream.Get(), nullptr, WICDecodeMetadataCacheOnDemand, &decoder))) {
+        return false;
+    }
+
+    ComPtr<IWICBitmapFrameDecode> frame;
+    if (FAILED(decoder->GetFrame(0, &frame))) {
+        return false;
+    }
+
+    ComPtr<IWICFormatConverter> converter;
+    if (FAILED(factory->CreateFormatConverter(&converter))) {
+        return false;
+    }
+    if (FAILED(converter->Initialize(
+            frame.Get(), GUID_WICPixelFormat32bppRGBA,
+            WICBitmapDitherTypeNone, nullptr, 0.0, WICBitmapPaletteTypeCustom))) {
+        return false;
+    }
+
+    UINT w = 0, h = 0;
+    converter->GetSize(&w, &h);
+    out.width = w;
+    out.height = h;
+    out.rgba.resize(static_cast<size_t>(w) * h * 4);
+
+    const UINT stride = w * 4;
+    if (FAILED(converter->CopyPixels(
+            nullptr, stride, static_cast<UINT>(out.rgba.size()), out.rgba.data()))) {
+        return false;
+    }
+    return true;
+}
+
+} // namespace next2d

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

@@ -0,0 +1,16 @@
+// WIC (Windows Imaging Component) による画像デコード。V8 非依存。
+// Image.cpp (createImageBitmap / Image.src) と単体テストの両方から使う。
+#pragma once
+
+#include "ImageTypes.h"
+
+#include <cstdint>
+#include <vector>
+
+namespace next2d {
+
+// 任意フォーマット(PNG/JPEG/GIF/BMP 等)のバイト列を RGBA8 straight へデコードする。
+// 呼び出し前に COM が初期化されている必要がある (CoInitializeEx)。
+bool DecodeImageWithWIC(const std::vector<uint8_t>& input, DecodedImage& out);
+
+} // namespace next2d

package/templates/xbox/src/v8/V8Runtime.cpp

@@ -0,0 +1,285 @@
+#include "V8Runtime.h"
+
+#include "V8Util.h"
+#include "HostContext.h"
+#include "bindings/Bindings.h"
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+namespace fs = std::filesystem;
+
+namespace next2d {
+
+std::unique_ptr<v8::Platform> V8Runtime::platform_;
+
+// isolate data slot 1: V8Runtime* (ESM resolve コールバックから参照)
+constexpr uint32_t kRuntimeSlot = 1;
+
+namespace {
+
+std::string ReadTextFile(const std::string& path)
+{
+    std::ifstream ifs(path, std::ios::binary);
+    if (!ifs) {
+        return {};
+    }
+    std::ostringstream oss;
+    oss << ifs.rdbuf();
+    return oss.str();
+}
+
+} // namespace
+
+V8Runtime::V8Runtime() = default;
+
+V8Runtime::~V8Runtime()
+{
+    Dispose();
+}
+
+void V8Runtime::InitializeProcess(const char* exec_path)
+{
+    // Xbox(GDK) / Nintendo Switch のリテール環境は動的コード生成(JIT)を禁止する。
+    // V8 を jitless (Ignition インタプリタのみ・TurboFan/Sparkplug/RWXページ無し) で動かす。
+    // prebuilt V8 (build-v8.yml) は v8_jitless=true + turbofan/wasm 無効でビルドされる。
+    // wasm/opt 系フラグはそのビルドに存在しないため渡さない (未知フラグ警告を避ける)。
+    v8::V8::SetFlagsFromString("--jitless");
+
+    v8::V8::InitializeICUDefaultLocation(exec_path);
+    v8::V8::InitializeExternalStartupData(exec_path);
+    platform_ = v8::platform::NewDefaultPlatform();
+    v8::V8::InitializePlatform(platform_.get());
+    v8::V8::Initialize();
+}
+
+void V8Runtime::ShutdownProcess()
+{
+    v8::V8::Dispose();
+    v8::V8::DisposePlatform();
+    platform_.reset();
+}
+
+bool V8Runtime::Initialize(HostContext* host)
+{
+    host_ = host;
+
+    create_params_.array_buffer_allocator =
+        v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+
+    isolate_ = v8::Isolate::New(create_params_);
+    isolate_->SetData(kHostContextSlot, host);
+    isolate_->SetData(kRuntimeSlot, this);
+
+    // 例外時に未処理を潰さないよう、明示的に MicrotasksPolicy を制御する
+    isolate_->SetMicrotasksPolicy(v8::MicrotasksPolicy::kExplicit);
+
+    v8::Isolate::Scope isolate_scope(isolate_);
+    v8::HandleScope handle_scope(isolate_);
+
+    v8::Local<v8::Context> context = v8::Context::New(isolate_);
+    context_.Reset(isolate_, context);
+
+    v8::Context::Scope context_scope(context);
+
+    // ブラウザ相当グローバルをインストール
+    InstallGlobalBindings(isolate_, context->Global(), host_);
+
+    return true;
+}
+
+void V8Runtime::Dispose()
+{
+    module_cache_.clear();
+    module_paths_.clear();
+    context_.Reset();
+
+    if (isolate_) {
+        isolate_->Dispose();
+        isolate_ = nullptr;
+    }
+    if (create_params_.array_buffer_allocator) {
+        delete create_params_.array_buffer_allocator;
+        create_params_.array_buffer_allocator = nullptr;
+    }
+}
+
+v8::Local<v8::Context> V8Runtime::context() const
+{
+    return context_.Get(isolate_);
+}
+
+bool V8Runtime::RunScript(const std::string& source, const std::string& name)
+{
+    v8::Isolate::Scope isolate_scope(isolate_);
+    v8::HandleScope handle_scope(isolate_);
+    v8::Local<v8::Context> ctx = context();
+    v8::Context::Scope context_scope(ctx);
+
+    v8::TryCatch try_catch(isolate_);
+
+    v8::ScriptOrigin origin(v8util::Str(isolate_, name));
+    v8::Local<v8::String> src = v8util::Str(isolate_, source);
+
+    v8::Local<v8::Script> script;
+    if (!v8::Script::Compile(ctx, src, &origin).ToLocal(&script)) {
+        ReportException(&try_catch);
+        return false;
+    }
+
+    v8::Local<v8::Value> result;
+    if (!script->Run(ctx).ToLocal(&result)) {
+        ReportException(&try_catch);
+        return false;
+    }
+
+    PumpMicrotasks();
+    return true;
+}
+
+v8::MaybeLocal<v8::Module> V8Runtime::LoadModule(const std::string& path,
+                                                const std::string& /*referrer_dir*/)
+{
+    const std::string abs = fs::weakly_canonical(path).string();
+
+    auto cached = module_cache_.find(abs);
+    if (cached != module_cache_.end()) {
+        return cached->second.Get(isolate_);
+    }
+
+    const std::string source = ReadTextFile(abs);
+    if (source.empty() && !fs::exists(abs)) {
+        v8util::ThrowTypeError(isolate_, "Module not found: " + abs);
+        return v8::MaybeLocal<v8::Module>();
+    }
+
+    v8::Local<v8::String> src = v8util::Str(isolate_, source);
+
+    v8::ScriptOrigin origin(
+        v8util::Str(isolate_, abs),
+        0, 0, false, -1, v8::Local<v8::Value>(),
+        false, false, /*is_module*/ true
+    );
+
+    v8::ScriptCompiler::Source compiler_source(src, origin);
+    v8::Local<v8::Module> module;
+    if (!v8::ScriptCompiler::CompileModule(isolate_, &compiler_source).ToLocal(&module)) {
+        return v8::MaybeLocal<v8::Module>();
+    }
+
+    module_cache_[abs].Reset(isolate_, module);
+    module_paths_[module->GetIdentityHash()] = abs;
+
+    // 依存モジュールを再帰的にロード
+    v8::Local<v8::FixedArray> requests = module->GetModuleRequests();
+    const std::string dir = fs::path(abs).parent_path().string();
+    for (int i = 0; i < requests->Length(); ++i) {
+        v8::Local<v8::ModuleRequest> request =
+            requests->Get(context(), i).As<v8::ModuleRequest>();
+        const std::string specifier =
+            v8util::ToStdString(isolate_, request->GetSpecifier());
+        const std::string resolved = (fs::path(dir) / specifier).string();
+        if (LoadModule(resolved, dir).IsEmpty()) {
+            return v8::MaybeLocal<v8::Module>();
+        }
+    }
+
+    return module;
+}
+
+v8::MaybeLocal<v8::Module> V8Runtime::ResolveModuleCallback(
+    v8::Local<v8::Context> context,
+    v8::Local<v8::String> specifier,
+    v8::Local<v8::FixedArray> /*import_assertions*/,
+    v8::Local<v8::Module> referrer)
+{
+    v8::Isolate* isolate = context->GetIsolate();
+    auto* self = static_cast<V8Runtime*>(isolate->GetData(kRuntimeSlot));
+
+    auto it = self->module_paths_.find(referrer->GetIdentityHash());
+    const std::string referrer_dir = (it != self->module_paths_.end())
+        ? fs::path(it->second).parent_path().string()
+        : std::string();
+
+    const std::string spec = v8util::ToStdString(isolate, specifier);
+    const std::string resolved = (fs::path(referrer_dir) / spec).string();
+    return self->LoadModule(resolved, referrer_dir);
+}
+
+bool V8Runtime::RunModule(const std::string& /*source*/, const std::string& path)
+{
+    v8::Isolate::Scope isolate_scope(isolate_);
+    v8::HandleScope handle_scope(isolate_);
+    v8::Local<v8::Context> ctx = context();
+    v8::Context::Scope context_scope(ctx);
+
+    v8::TryCatch try_catch(isolate_);
+
+    v8::Local<v8::Module> module;
+    if (!LoadModule(path, fs::path(path).parent_path().string()).ToLocal(&module)) {
+        ReportException(&try_catch);
+        return false;
+    }
+
+    if (module->InstantiateModule(ctx, ResolveModuleCallback).IsNothing()) {
+        ReportException(&try_catch);
+        return false;
+    }
+
+    v8::Local<v8::Value> result;
+    if (!module->Evaluate(ctx).ToLocal(&result)) {
+        ReportException(&try_catch);
+        return false;
+    }
+
+    // トップレベル await の完了を待つためマイクロタスクを回す
+    PumpMicrotasks();
+
+    if (module->GetStatus() == v8::Module::kErrored) {
+        v8::Local<v8::Value> exception = module->GetException();
+        std::cerr << "[V8] Module evaluation error: "
+                  << v8util::ToStdString(isolate_, exception) << std::endl;
+        return false;
+    }
+
+    return true;
+}
+
+void V8Runtime::PumpMicrotasks()
+{
+    isolate_->PerformMicrotaskCheckpoint();
+}
+
+void V8Runtime::PumpPlatformTasks()
+{
+    while (v8::platform::PumpMessageLoop(platform_.get(), isolate_)) {
+        // フォアグラウンドタスクを空になるまで処理
+    }
+}
+
+void V8Runtime::ReportException(v8::TryCatch* try_catch)
+{
+    v8::HandleScope handle_scope(isolate_);
+    const std::string exception = v8util::ToStdString(isolate_, try_catch->Exception());
+
+    v8::Local<v8::Message> message = try_catch->Message();
+    if (message.IsEmpty()) {
+        std::cerr << "[V8] " << exception << std::endl;
+        return;
+    }
+
+    v8::Local<v8::Context> ctx = context();
+    const std::string filename =
+        v8util::ToStdString(isolate_, message->GetScriptOrigin().ResourceName());
+    const int linenum = message->GetLineNumber(ctx).FromMaybe(0);
+    std::cerr << "[V8] " << filename << ":" << linenum << ": " << exception << std::endl;
+
+    v8::Local<v8::Value> stack_trace;
+    if (try_catch->StackTrace(ctx).ToLocal(&stack_trace)) {
+        std::cerr << v8util::ToStdString(isolate_, stack_trace) << std::endl;
+    }
+}
+
+} // namespace next2d