@goliapkg/sentori-react-native 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# @sentori/react-native
+
+React Native SDK — JS / iOS native / Android native error capture.
+
+JS layer in **Phase 3**, native layers in **Phase 7**. Currently a placeholder.

package/SentoriReactNative.podspec

@@ -0,0 +1,21 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'SentoriReactNative'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = 'TBD'
+  s.author         = { 'Sentori' => 'support@sentori.golia.jp' }
+  s.homepage       = 'https://sentori.golia.jp'
+  s.platforms      = { ios: '13.4', tvos: '13.4' }
+  s.swift_version  = '5.4'
+  s.source         = { git: '' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  s.source_files = 'ios/**/*.{h,m,mm,swift,hpp,cpp}'
+end

package/android/build.gradle

@@ -0,0 +1,38 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+group = 'com.sentori'
+version = rootProject.hasProperty('sentoriPackageVersion')
+    ? rootProject.sentoriPackageVersion
+    : '0.0.0'
+
+android {
+    namespace 'com.sentori'
+    compileSdk rootProject.hasProperty('compileSdkVersion') ? rootProject.compileSdkVersion : 35
+
+    defaultConfig {
+        minSdk rootProject.hasProperty('minSdkVersion') ? rootProject.minSdkVersion : 24
+        targetSdk rootProject.hasProperty('targetSdkVersion') ? rootProject.targetSdkVersion : 35
+    }
+
+    sourceSets {
+        main {
+            manifest.srcFile 'src/main/AndroidManifest.xml'
+            java.srcDirs = ['src/main/java']
+        }
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+
+dependencies {
+    implementation project(':expo-modules-core')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${rootProject.ext.kotlinVersion ?: '2.0.21'}"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/com/sentori/SentoriCrashHandler.kt

@@ -0,0 +1,213 @@
+package com.sentori
+
+import android.content.Context
+import android.os.Build
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+import java.util.UUID
+
+/**
+ * Static crash handler — captures Java/Kotlin uncaught exceptions on
+ * Android and writes one event-shaped JSON file per crash to
+ * <filesDir>/sentori/pending/<uuid>.json. JS drains that directory on
+ * next launch via Sentori.drainPending().
+ *
+ * What this does NOT do (Phase 7 v0.1):
+ *   - native crashes (NDK / SIGSEGV) — Phase 7 explicitly skips signal-
+ *     based handlers per ROADMAP.
+ *   - ANR detection — deferred to v0.2.
+ */
+object SentoriCrashHandler {
+
+    private const val PREFS = "sentori"
+    private const val PENDING_DIR_NAME = "sentori/pending"
+
+    @Volatile private var appCtx: Context? = null
+    @Volatile private var previousHandler: Thread.UncaughtExceptionHandler? = null
+
+    @JvmStatic
+    fun register(context: Context) {
+        appCtx = context.applicationContext
+        previousHandler = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            try {
+                write(throwable)
+            } catch (_: Throwable) {
+                // never throw inside the crash handler
+            }
+            previousHandler?.uncaughtException(thread, throwable)
+        }
+    }
+
+    @JvmStatic
+    fun setConfig(config: Map<String, Any?>) {
+        val ctx = appCtx ?: return
+        val prefs = ctx.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+        val edit = prefs.edit()
+        edit.clear()
+        for ((k, v) in config) {
+            when (v) {
+                is String -> edit.putString(k, v)
+                is Int -> edit.putInt(k, v)
+                is Boolean -> edit.putBoolean(k, v)
+                else -> {}
+            }
+        }
+        edit.apply()
+    }
+
+    @JvmStatic
+    fun consumePending(): List<String> {
+        val dir = pendingDir() ?: return emptyList()
+        if (!dir.exists()) return emptyList()
+        val out = mutableListOf<String>()
+        val files = dir.listFiles { f -> f.extension == "json" } ?: emptyArray()
+        for (f in files) {
+            try {
+                out.add(f.readText())
+            } catch (_: Throwable) {
+                // skip unreadable file
+            }
+            f.delete()
+        }
+        return out
+    }
+
+    // ── internals ────────────────────────────────────────────────
+
+    private fun pendingDir(): File? {
+        val ctx = appCtx ?: return null
+        val dir = File(ctx.filesDir, PENDING_DIR_NAME)
+        if (!dir.exists()) dir.mkdirs()
+        return dir
+    }
+
+    private fun configMap(): Map<String, String> {
+        val ctx = appCtx ?: return emptyMap()
+        val prefs = ctx.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+        val out = mutableMapOf<String, String>()
+        for ((k, v) in prefs.all) if (v is String) out[k] = v
+        return out
+    }
+
+    private fun write(throwable: Throwable) {
+        val cfg = configMap()
+        val release = cfg["release"] ?: "unknown"
+        val environment = cfg["environment"] ?: "prod"
+
+        val device = JSONObject().apply {
+            put("os", "android")
+            put("osVersion", Build.VERSION.RELEASE)
+            put("model", "${Build.MANUFACTURER} ${Build.MODEL}")
+        }
+
+        val app = JSONObject().apply {
+            put("version", appVersion())
+            put("build", appBuild())
+        }
+
+        val error = errorToJson(throwable)
+
+        val event = JSONObject().apply {
+            put("id", uuidLower())
+            put("timestamp", iso8601Now())
+            put("kind", "error")
+            put("platform", "android")
+            put("release", release)
+            put("environment", environment)
+            put("device", device)
+            put("app", app)
+            put("user", JSONObject.NULL)
+            put("tags", JSONObject())
+            put("breadcrumbs", JSONArray())
+            put("error", error)
+            put("fingerprint", JSONArray())
+            put("traceId", JSONObject.NULL)
+            put("spanId", JSONObject.NULL)
+        }
+
+        val dir = pendingDir() ?: return
+        val file = File(dir, "${uuidLower()}.json")
+        try {
+            file.writeText(event.toString())
+        } catch (_: Throwable) {
+            // best-effort
+        }
+    }
+
+    private fun errorToJson(throwable: Throwable): JSONObject {
+        return JSONObject().apply {
+            put("type", throwable.javaClass.name)
+            put("message", throwable.message ?: "")
+            put("stack", framesToJson(throwable))
+            val cause = throwable.cause
+            if (cause != null && cause !== throwable) {
+                put("cause", errorToJson(cause))
+            } else {
+                put("cause", JSONObject.NULL)
+            }
+        }
+    }
+
+    private fun framesToJson(throwable: Throwable): JSONArray {
+        val arr = JSONArray()
+        for (f in throwable.stackTrace) {
+            val frame = JSONObject().apply {
+                put("function", "${f.className}.${f.methodName}")
+                put("file", f.fileName ?: "<unknown>")
+                put("line", f.lineNumber.coerceAtLeast(0))
+                put("inApp", isInApp(f))
+            }
+            arr.put(frame)
+        }
+        return arr
+    }
+
+    private fun isInApp(f: StackTraceElement): Boolean {
+        val cls = f.className
+        if (cls.startsWith("android.")) return false
+        if (cls.startsWith("androidx.")) return false
+        if (cls.startsWith("java.")) return false
+        if (cls.startsWith("javax.")) return false
+        if (cls.startsWith("kotlin.")) return false
+        if (cls.startsWith("kotlinx.")) return false
+        if (cls.startsWith("com.facebook.react.")) return false
+        if (cls.startsWith("com.android.")) return false
+        if (cls.startsWith("dalvik.")) return false
+        if (cls.startsWith("sun.")) return false
+        return true
+    }
+
+    private fun iso8601Now(): String {
+        val f = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US)
+        f.timeZone = TimeZone.getTimeZone("UTC")
+        return f.format(Date())
+    }
+
+    private fun uuidLower(): String = UUID.randomUUID().toString().lowercase(Locale.US)
+
+    private fun appVersion(): String {
+        val ctx = appCtx ?: return "0.0.0"
+        return try {
+            val pi = ctx.packageManager.getPackageInfo(ctx.packageName, 0)
+            pi.versionName ?: "0.0.0"
+        } catch (_: Throwable) {
+            "0.0.0"
+        }
+    }
+
+    private fun appBuild(): String {
+        val ctx = appCtx ?: return "0"
+        return try {
+            val pi = ctx.packageManager.getPackageInfo(ctx.packageName, 0)
+            pi.longVersionCode.toString()
+        } catch (_: Throwable) {
+            "0"
+        }
+    }
+}

package/android/src/main/java/com/sentori/SentoriModule.kt

@@ -0,0 +1,39 @@
+package com.sentori
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+/**
+ * Expo Module exposing the Android crash handler to JS. Same JS contract
+ * as the iOS module:
+ *   - setConfig({ token, release, environment })
+ *   - drainPending() -> List<String>  (JSON bodies)
+ */
+class SentoriModule : Module() {
+    override fun definition() = ModuleDefinition {
+        Name("Sentori")
+
+        OnCreate {
+            val ctx = appContext.reactContext ?: return@OnCreate
+            SentoriCrashHandler.register(ctx)
+        }
+
+        Function("setConfig") { config: Map<String, Any?> ->
+            SentoriCrashHandler.setConfig(config)
+        }
+
+        AsyncFunction("drainPending") {
+            SentoriCrashHandler.consumePending()
+        }
+
+        // Dev-only helper — schedules an uncaught RuntimeException after
+        // a tick so the JS bridge has time to return; the crash is then
+        // captured by SentoriCrashHandler and written to
+        // <filesDir>/sentori/pending/.
+        Function("triggerTestNativeCrash") {
+            android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+                throw RuntimeException("Sentori test native crash")
+            }, 50)
+        }
+    }
+}

package/android/src/test/java/com/sentori/SentoriCrashHandlerTest.kt

@@ -0,0 +1,60 @@
+// Phase 16 sub-E: Robolectric coverage for SentoriCrashHandler (回填 Phase 7).
+//
+// Run via Gradle on the Android host:
+//   ./gradlew :sentori-react-native:testDebugUnitTest
+//
+// We can't easily catch a real uncaught Throwable in-process (the test
+// runner would itself crash), so we drive the persistence helper
+// directly and assert it writes a protocol-shaped JSON file.
+
+package com.sentori
+
+import androidx.test.core.app.ApplicationProvider
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.json.JSONObject
+import java.io.File
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+@RunWith(RobolectricTestRunner::class)
+class SentoriCrashHandlerTest {
+    private lateinit var pendingDir: File
+
+    @Before
+    fun setUp() {
+        val ctx = ApplicationProvider.getApplicationContext<android.content.Context>()
+        pendingDir = File(ctx.filesDir, "sentori/pending")
+        pendingDir.deleteRecursively()
+        pendingDir.mkdirs()
+        SentoriCrashHandler.installForTesting(ctx)
+    }
+
+    @After
+    fun tearDown() {
+        pendingDir.deleteRecursively()
+    }
+
+    @Test
+    fun writePendingProducesValidEventJson() {
+        val ex = RuntimeException("boom from robolectric")
+        SentoriCrashHandler.persistForTesting(ex, "android-test-thread")
+
+        val files = pendingDir.listFiles { f -> f.name.endsWith(".json") }
+        assertNotNull(files, "no listing in $pendingDir")
+        assertEquals(1, files.size, "expected exactly one pending file")
+
+        val payload = JSONObject(files[0].readText())
+        assertEquals("error", payload.getString("kind"))
+        assertEquals("android", payload.getString("platform"))
+        assertNotNull(payload.getString("id"))
+        assertNotNull(payload.getString("timestamp"))
+        val error = payload.getJSONObject("error")
+        assertEquals("RuntimeException", error.getString("type"))
+        assertTrue(error.getString("message").contains("boom"))
+    }
+}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["SentoriModule"]
+  },
+  "android": {
+    "modules": ["com.sentori.SentoriModule"]
+  }
+}

package/ios/SentoriCrashHandler.swift

@@ -0,0 +1,160 @@
+import Foundation
+
+/// Static crash handler — captures NSException and writes one JSON file
+/// per crash to <Documents>/sentori/pending/<uuid>.json. JS drains that
+/// directory on next launch via `Sentori.drainPending()`.
+///
+/// What this does NOT do (Phase 7 v0.1):
+///   - signal-based native crashes (SIGSEGV / SIGABRT etc.) — see ROADMAP
+///     "explicitly out" list. Only Objective-C exceptions are caught here.
+@objc public final class SentoriCrashHandler: NSObject {
+
+    private static let configKey = "com.sentori.config"
+    private static let pendingDirName = "sentori/pending"
+
+    /// Install the global uncaught-exception handler. C function pointer,
+    /// so we cannot capture local context (no chaining to a previously
+    /// installed handler in v0.1 — RedBox in dev still receives via
+    /// JS-side handlers; in release this just replaces the default).
+    @objc public static func register() {
+        NSSetUncaughtExceptionHandler(SentoriCrashHandler.exceptionHandler)
+    }
+
+    private static let exceptionHandler: @convention(c) (NSException) -> Void = { exception in
+        SentoriCrashHandler.write(exception: exception)
+    }
+
+    /// JS side calls this on `sentori.init(...)` so the crash handler
+    /// has release / environment when an exception fires later.
+    @objc public static func setConfig(_ config: [String: Any]) {
+        UserDefaults.standard.set(config, forKey: configKey)
+    }
+
+    /// Read all pending-crash files, return their contents (UTF-8 JSON
+    /// strings), and remove them from disk. Best-effort: any I/O error
+    /// drops that one file silently.
+    @objc public static func consumePending() -> [String] {
+        guard let dir = pendingDir() else { return [] }
+        let urls = (try? FileManager.default.contentsOfDirectory(
+            at: dir, includingPropertiesForKeys: nil)) ?? []
+        var out: [String] = []
+        for url in urls where url.pathExtension == "json" {
+            if let data = try? Data(contentsOf: url),
+               let str = String(data: data, encoding: .utf8) {
+                out.append(str)
+            }
+            try? FileManager.default.removeItem(at: url)
+        }
+        return out
+    }
+
+    // MARK: - Internals
+
+    private static func pendingDir() -> URL? {
+        guard let docs = FileManager.default.urls(
+            for: .documentDirectory, in: .userDomainMask).first else { return nil }
+        let dir = docs.appendingPathComponent(pendingDirName)
+        try? FileManager.default.createDirectory(
+            at: dir, withIntermediateDirectories: true)
+        return dir
+    }
+
+    private static func config() -> [String: Any] {
+        return UserDefaults.standard.dictionary(forKey: configKey) ?? [:]
+    }
+
+    private static func write(exception: NSException) {
+        let cfg = config()
+        let release = (cfg["release"] as? String) ?? "unknown"
+        let environment = (cfg["environment"] as? String) ?? "prod"
+
+        let event: [String: Any] = [
+            "id": UUID().uuidString.lowercased(),
+            "timestamp": iso8601(Date()),
+            "kind": "error",
+            "platform": "ios",
+            "release": release,
+            "environment": environment,
+            "device": [
+                "os": "ios",
+                "osVersion": osVersion(),
+                "model": deviceModel(),
+            ],
+            "app": appInfo(),
+            "user": NSNull(),
+            "tags": [String: String](),
+            "breadcrumbs": [Any](),
+            "error": [
+                "type": exception.name.rawValue,
+                "message": exception.reason ?? "",
+                "stack": frames(from: exception.callStackSymbols),
+                "cause": NSNull(),
+            ],
+            "fingerprint": [String](),
+            "traceId": NSNull(),
+            "spanId": NSNull(),
+        ]
+
+        guard let dir = pendingDir() else { return }
+        let url = dir.appendingPathComponent("\(UUID().uuidString.lowercased()).json")
+        if let data = try? JSONSerialization.data(withJSONObject: event, options: []) {
+            try? data.write(to: url)
+        }
+    }
+
+    private static func iso8601(_ date: Date) -> String {
+        let f = ISO8601DateFormatter()
+        f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        return f.string(from: date)
+    }
+
+    private static func osVersion() -> String {
+        let v = ProcessInfo.processInfo.operatingSystemVersion
+        return "\(v.majorVersion).\(v.minorVersion).\(v.patchVersion)"
+    }
+
+    private static func deviceModel() -> String {
+        var s = utsname()
+        uname(&s)
+        return withUnsafePointer(to: &s.machine) { ptr in
+            ptr.withMemoryRebound(to: CChar.self, capacity: 1) {
+                String(validatingUTF8: $0) ?? "unknown"
+            }
+        }
+    }
+
+    private static func appInfo() -> [String: Any] {
+        let info = Bundle.main.infoDictionary ?? [:]
+        var d: [String: Any] = [
+            "version": (info["CFBundleShortVersionString"] as? String) ?? "0.0.0",
+        ]
+        if let build = info["CFBundleVersion"] as? String {
+            d["build"] = build
+        }
+        return d
+    }
+
+    /// Best-effort frame parse from `[NSException callStackSymbols]`.
+    /// Each line looks roughly like:
+    ///   "1   AppName    0x0001a0b0 -[ClassName method:] + 100"
+    /// We don't have file/line info in raw symbol output; sourcemap-style
+    /// symbolication for native happens server-side (Phase 8+).
+    private static func frames(from symbols: [String]) -> [[String: Any]] {
+        return symbols.map { sym -> [String: Any] in
+            let parts = sym.split(separator: " ", omittingEmptySubsequences: true).map(String.init)
+            let module = parts.count > 1 ? parts[1] : "<unknown>"
+            let function = parts.count > 3 ? parts.dropFirst(3).joined(separator: " ") : "<anonymous>"
+            let inApp = !module.contains("UIKit")
+                && !module.contains("Foundation")
+                && !module.contains("CoreFoundation")
+                && !module.contains("libsystem")
+                && !module.contains("libobjc")
+            return [
+                "function": function,
+                "file": module,
+                "line": 0,
+                "inApp": inApp,
+            ]
+        }
+    }
+}

package/ios/SentoriModule.swift

@@ -0,0 +1,43 @@
+import ExpoModulesCore
+
+/// Expo Module exposing the iOS crash handler to JS.
+///
+/// JS contract (mirrored in src/native.ts):
+///   - setConfig({ token, release, environment }): stash for the crash
+///     writer. Token is currently unused at native side; release and
+///     environment are baked into the saved event JSON.
+///   - drainPending() → string[]: read & delete all pending crash files
+///     from <Documents>/sentori/pending and return their JSON bodies.
+public class SentoriModule: Module {
+    public func definition() -> ModuleDefinition {
+        Name("Sentori")
+
+        OnCreate {
+            SentoriCrashHandler.register()
+        }
+
+        Function("setConfig") { (config: [String: Any]) in
+            SentoriCrashHandler.setConfig(config)
+        }
+
+        AsyncFunction("drainPending") { () -> [String] in
+            return SentoriCrashHandler.consumePending()
+        }
+
+        // Dev-only helper used by the example app to verify the
+        // crash-write / drain round-trip without writing native code in
+        // the host app. Schedules a real NSException after a tick so
+        // the JS bridge has time to return; the resulting crash hits
+        // SentoriCrashHandler and writes a JSON file under
+        // <Documents>/sentori/pending/.
+        Function("triggerTestNativeCrash") {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
+                NSException(
+                    name: NSExceptionName("SentoriTestException"),
+                    reason: "Sentori test native crash",
+                    userInfo: nil
+                ).raise()
+            }
+        }
+    }
+}

package/ios/Tests/SentoriCrashHandlerTests.swift

@@ -0,0 +1,59 @@
+// Phase 16 sub-E: XCTest coverage for SentoriCrashHandler (回填 Phase 7).
+//
+// Run via Xcode (target → SentoriTests, ⌘U) or via xcodebuild from the
+// iOS host:
+//   xcodebuild test \
+//     -scheme SentoriTests \
+//     -destination 'platform=iOS Simulator,name=iPhone 15'
+//
+// The handler writes one JSON file per crash to
+//   <Documents>/sentori/pending/<uuid>.json
+// We can't easily re-raise NSException (it tears down the test
+// process), so we exercise the persistence helper directly instead.
+
+import XCTest
+@testable import SentoriCrashHandler
+
+final class SentoriCrashHandlerTests: XCTestCase {
+    private var pendingDir: URL!
+
+    override func setUpWithError() throws {
+        let docs = try FileManager.default.url(
+            for: .documentDirectory,
+            in: .userDomainMask,
+            appropriateFor: nil,
+            create: true
+        )
+        pendingDir = docs.appendingPathComponent("sentori/pending", isDirectory: true)
+        try? FileManager.default.removeItem(at: pendingDir)
+        try FileManager.default.createDirectory(at: pendingDir, withIntermediateDirectories: true)
+    }
+
+    func testWritePendingProducesValidEventJson() throws {
+        // Synthesize a payload like the @convention(c) handler would.
+        let exception = NSException(
+            name: NSExceptionName("XCTestSyntheticException"),
+            reason: "boom",
+            userInfo: nil
+        )
+        SentoriCrashHandler.persistForTesting(exception: exception)
+
+        let files = try FileManager.default.contentsOfDirectory(atPath: pendingDir.path)
+            .filter { $0.hasSuffix(".json") }
+        XCTAssertEqual(files.count, 1, "expected exactly one pending file, got \(files.count)")
+
+        let url = pendingDir.appendingPathComponent(files[0])
+        let data = try Data(contentsOf: url)
+        let payload = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
+        XCTAssertNotNil(payload, "pending file is not valid JSON")
+
+        // Spot-check the protocol shape (Phase 1 schema).
+        XCTAssertEqual(payload?["kind"] as? String, "error")
+        XCTAssertEqual(payload?["platform"] as? String, "ios")
+        XCTAssertNotNil(payload?["id"] as? String)
+        XCTAssertNotNil(payload?["timestamp"] as? String)
+        let error = payload?["error"] as? [String: Any]
+        XCTAssertEqual(error?["type"] as? String, "XCTestSyntheticException")
+        XCTAssertEqual(error?["message"] as? String, "boom")
+    }
+}

package/lib/breadcrumbs.d.ts

@@ -0,0 +1,11 @@
+import type { Breadcrumb, BreadcrumbType } from './types';
+export type AddBreadcrumbInput = {
+    type: BreadcrumbType;
+    data: Record<string, unknown>;
+    timestamp?: string;
+};
+export declare const addBreadcrumb: (input: AddBreadcrumbInput) => void;
+export declare const getBreadcrumbs: () => Breadcrumb[];
+export declare const clearBreadcrumbs: () => void;
+export declare const __resetForTests: () => void;
+//# sourceMappingURL=breadcrumbs.d.ts.map

package/lib/breadcrumbs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breadcrumbs.d.ts","sourceRoot":"","sources":["../src/breadcrumbs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAM1D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,OAAO,kBAAkB,KAAG,IAUzD,CAAC;AAEF,eAAO,MAAM,cAAc,QAAO,UAAU,EAAkB,CAAC;AAE/D,eAAO,MAAM,gBAAgB,QAAO,IAEnC,CAAC;AAEF,eAAO,MAAM,eAAe,QAAO,IAElC,CAAC"}