@cloudcare/cocos-sdk 0.1.1-alpha.1 → 0.1.1-alpha.2

package/runtime/native.js

@@ -0,0 +1,1191 @@
+"use strict";
+(function() {
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __commonJS = function(cb, mod) {
+    return function __require() {
+      try {
+        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+      } catch (e) {
+        throw mod = 0, e;
+      }
+    };
+  };
+
+  // packages/cocos/dist/creator2/core/auto-tracking.js
+  var require_auto_tracking = __commonJS({
+    "packages/cocos/dist/creator2/core/auto-tracking.js": function(exports) {
+      "use strict";
+      var __assign = exports && exports.__assign || function() {
+        __assign = Object.assign || function(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+          }
+          return t;
+        };
+        return __assign.apply(this, arguments);
+      };
+      var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+        function adopt(value) {
+          return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+          });
+        }
+        return new (P || (P = Promise))(function(resolve, reject) {
+          function fulfilled(value) {
+            try {
+              step(generator.next(value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function rejected(value) {
+            try {
+              step(generator["throw"](value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+      };
+      var __generator = exports && exports.__generator || function(thisArg, body) {
+        var _ = { label: 0, sent: function() {
+          if (t[0] & 1) throw t[1];
+          return t[1];
+        }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+        return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+          return this;
+        }), g;
+        function verb(n) {
+          return function(v) {
+            return step([n, v]);
+          };
+        }
+        function step(op) {
+          if (f) throw new TypeError("Generator is already executing.");
+          while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+              case 0:
+              case 1:
+                t = op;
+                break;
+              case 4:
+                _.label++;
+                return { value: op[1], done: false };
+              case 5:
+                _.label++;
+                y = op[1];
+                op = [0];
+                continue;
+              case 7:
+                op = _.ops.pop();
+                _.trys.pop();
+                continue;
+              default:
+                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                  _ = 0;
+                  continue;
+                }
+                if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                  _.label = op[1];
+                  break;
+                }
+                if (op[0] === 6 && _.label < t[1]) {
+                  _.label = t[1];
+                  t = op;
+                  break;
+                }
+                if (t && _.label < t[2]) {
+                  _.label = t[2];
+                  _.ops.push(op);
+                  break;
+                }
+                if (t[2]) _.ops.pop();
+                _.trys.pop();
+                continue;
+            }
+            op = body.call(thisArg, _);
+          } catch (e) {
+            op = [6, e];
+            y = 0;
+          } finally {
+            f = t = 0;
+          }
+          if (op[0] & 5) throw op[1];
+          return { value: op[0] ? op[1] : void 0, done: true };
+        }
+      };
+      var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FTDefaultAutoTracking = void 0;
+      var FTDefaultAutoTracking = (
+        /** @class */
+        (function() {
+          function FTDefaultAutoTracking2(rum, logger, trace, hooks, target) {
+            if (target === void 0) {
+              target = globalThis;
+            }
+            this.rum = rum;
+            this.logger = logger;
+            this.trace = trace;
+            this.hooks = hooks;
+            this.target = target;
+            this.stops = [];
+            this.networkStops = [];
+          }
+          FTDefaultAutoTracking2.prototype.start = function(config, viewName, scope) {
+            if (scope === void 0) {
+              scope = "all";
+            }
+            this.stop(scope);
+            try {
+              if (scope !== "network") {
+                if (viewName)
+                  this.switchView(viewName);
+                if (config.scenes)
+                  this.installSceneTracking(viewName === void 0);
+                if (config.actions)
+                  this.installActionTracking();
+                if (config.errors)
+                  this.installErrorTracking();
+                if (config.console)
+                  this.installConsoleTracking();
+              }
+              if (scope !== "page" && config.network) {
+                this.installFetchTracking();
+                this.installXhrTracking();
+              }
+            } catch (error) {
+              try {
+                this.stop(scope);
+              } catch (_a) {
+              }
+              throw error;
+            }
+          };
+          FTDefaultAutoTracking2.prototype.stop = function(scope) {
+            var _this = this;
+            if (scope === void 0) {
+              scope = "all";
+            }
+            var failure;
+            var cleanup = function(stop) {
+              try {
+                stop();
+              } catch (error) {
+                if (failure === void 0)
+                  failure = error;
+              }
+            };
+            if (scope !== "page")
+              this.networkStops.splice(0).reverse().forEach(cleanup);
+            if (scope !== "network") {
+              this.stops.splice(0).reverse().forEach(cleanup);
+              if (this.activeView) {
+                cleanup(function() {
+                  return _this.rum.stopView();
+                });
+                this.activeView = void 0;
+              }
+            }
+            if (failure !== void 0)
+              throw failure;
+          };
+          FTDefaultAutoTracking2.prototype.installSceneTracking = function(includeCurrent) {
+            var _this = this;
+            this.stops.push(this.hooks.onSceneChanged(function(name) {
+              _this.switchView(name);
+            }, includeCurrent));
+          };
+          FTDefaultAutoTracking2.prototype.switchView = function(name) {
+            if (this.activeView)
+              this.rum.stopView();
+            this.activeView = name;
+            this.rum.startView(name);
+          };
+          FTDefaultAutoTracking2.prototype.installActionTracking = function() {
+            var _this = this;
+            this.stops.push(this.hooks.onAction(function(name, attributes) {
+              return _this.rum.startAction(name, "click", attributes);
+            }));
+          };
+          FTDefaultAutoTracking2.prototype.installErrorTracking = function() {
+            var _this = this;
+            if (!this.target.addEventListener || !this.target.removeEventListener)
+              return;
+            var errorListener = function(event) {
+              var _a;
+              var errorEvent = event;
+              _this.rum.addError(errorEvent.message || "Uncaught JavaScript error", ((_a = errorEvent.error) === null || _a === void 0 ? void 0 : _a.stack) || "".concat(errorEvent.filename || "", ":").concat(errorEvent.lineno || 0));
+            };
+            var rejectionListener = function(event) {
+              var reason = event.reason;
+              _this.rum.addError(reason instanceof Error ? reason.message : String(reason), reason instanceof Error ? reason.stack || "" : "", "unhandled_promise_rejection");
+            };
+            this.target.addEventListener("error", errorListener);
+            this.target.addEventListener("unhandledrejection", rejectionListener);
+            this.stops.push(function() {
+              var _a, _b, _c, _d;
+              (_b = (_a = _this.target).removeEventListener) === null || _b === void 0 ? void 0 : _b.call(_a, "error", errorListener);
+              (_d = (_c = _this.target).removeEventListener) === null || _d === void 0 ? void 0 : _d.call(_c, "unhandledrejection", rejectionListener);
+            });
+          };
+          FTDefaultAutoTracking2.prototype.installConsoleTracking = function() {
+            var _this = this;
+            var consoleObject = this.target.console;
+            if (!consoleObject)
+              return;
+            var methods = [
+              "log",
+              "info",
+              "warn",
+              "error"
+            ];
+            var originals = /* @__PURE__ */ new Map();
+            methods.forEach(function(method) {
+              var original = consoleObject[method].bind(consoleObject);
+              originals.set(method, original);
+              consoleObject[method] = (function() {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                  args[_i] = arguments[_i];
+                }
+                original.apply(void 0, args);
+                var level = method === "warn" ? "warning" : method === "error" ? "error" : "info";
+                _this.logger.log(args.map(stringifyLogValue).join(" "), level);
+              });
+            });
+            this.stops.push(function() {
+              methods.forEach(function(method) {
+                var original = originals.get(method);
+                if (original)
+                  consoleObject[method] = original;
+              });
+            });
+          };
+          FTDefaultAutoTracking2.prototype.installFetchTracking = function() {
+            var _this = this;
+            var original = this.target.fetch;
+            if (!original)
+              return;
+            var tracked = (function(input, init) {
+              return __awaiter(_this, void 0, void 0, function() {
+                var inputObject, url, method, key, headers, start, response, end, error_1;
+                return __generator(this, function(_a) {
+                  switch (_a.label) {
+                    case 0:
+                      inputObject = typeof input === "object" ? input : void 0;
+                      url = typeof input === "string" ? input : (inputObject === null || inputObject === void 0 ? void 0 : inputObject.url) || String(input);
+                      method = (init === null || init === void 0 ? void 0 : init.method) || (inputObject === null || inputObject === void 0 ? void 0 : inputObject.method) || "GET";
+                      key = resourceKey();
+                      headers = createHeaders((init === null || init === void 0 ? void 0 : init.headers) || (inputObject === null || inputObject === void 0 ? void 0 : inputObject.headers));
+                      forEachOwn(this.trace.getHeaders(url, key), function(name, value) {
+                        return setHeader(headers, name, value);
+                      });
+                      this.rum.startResource(key);
+                      start = nowNs();
+                      _a.label = 1;
+                    case 1:
+                      _a.trys.push([1, 3, , 4]);
+                      return [4, original(input, __assign(__assign({}, init), { headers: headers }))];
+                    case 2:
+                      response = _a.sent();
+                      end = nowNs();
+                      this.rum.stopResource(key);
+                      this.rum.addResource(key, {
+                        url: url,
+                        httpMethod: method,
+                        requestHeaders: headersToObject(headers),
+                        responseHeaders: headersToObject(response.headers),
+                        statusCode: response.status
+                      }, { fetchStartTime: start, responseStartTime: end, responseEndTime: end });
+                      return [2, response];
+                    case 3:
+                      error_1 = _a.sent();
+                      this.rum.stopResource(key);
+                      this.rum.addError(String(error_1), error_1 instanceof Error ? error_1.stack || "" : "", "network_error");
+                      throw error_1;
+                    case 4:
+                      return [
+                        2
+                        /*return*/
+                      ];
+                  }
+                });
+              });
+            });
+            this.networkStops.push(function() {
+              _this.target.fetch = original;
+            });
+            this.target.fetch = tracked;
+          };
+          FTDefaultAutoTracking2.prototype.installXhrTracking = function() {
+            var Xhr = this.target.XMLHttpRequest;
+            if (!Xhr)
+              return;
+            var open = Xhr.prototype.open;
+            var send = Xhr.prototype.send;
+            var setRequestHeader = Xhr.prototype.setRequestHeader;
+            var metadata = /* @__PURE__ */ new WeakMap();
+            var rum = this.rum;
+            var trace = this.trace;
+            this.networkStops.push(function() {
+              Xhr.prototype.open = open;
+            });
+            Xhr.prototype.open = function trackedOpen(method, url) {
+              var _a;
+              var rest = [];
+              for (var _i = 2; _i < arguments.length; _i++) {
+                rest[_i - 2] = arguments[_i];
+              }
+              metadata.set(this, { key: resourceKey(), method: method, url: String(url), headers: {} });
+              (_a = open).call.apply(_a, __spreadArray([this, method, url], rest, false));
+            };
+            this.networkStops.push(function() {
+              Xhr.prototype.setRequestHeader = setRequestHeader;
+            });
+            Xhr.prototype.setRequestHeader = function trackedHeader(name, value) {
+              var data = metadata.get(this);
+              if (data)
+                data.headers[name] = value;
+              setRequestHeader.call(this, name, value);
+            };
+            this.networkStops.push(function() {
+              Xhr.prototype.send = send;
+            });
+            Xhr.prototype.send = function trackedSend(body) {
+              var _this = this;
+              var data = metadata.get(this);
+              if (!data)
+                return send.call(this, body);
+              forEachOwn(trace.getHeaders(data.url, data.key), function(name, value) {
+                data.headers[name] = value;
+                setRequestHeader.call(_this, name, value);
+              });
+              var started = nowNs();
+              rum.startResource(data.key);
+              var completed = false;
+              var report = function() {
+                if (completed)
+                  return;
+                completed = true;
+                var ended = nowNs();
+                rum.stopResource(data.key);
+                rum.addResource(data.key, {
+                  url: data.url,
+                  httpMethod: data.method,
+                  requestHeaders: data.headers,
+                  responseHeaders: parseXhrHeaders(_this.getAllResponseHeaders()),
+                  statusCode: _this.status
+                }, { fetchStartTime: started, responseStartTime: ended, responseEndTime: ended });
+              };
+              var originalLoadEnd = this.onloadend;
+              this.addEventListener("loadend", report, { once: true });
+              if (this.onloadend === report) {
+                var xhr_1 = this;
+                var handler_1 = function(event) {
+                  if (xhr_1.onloadend === handler_1)
+                    xhr_1.onloadend = originalLoadEnd;
+                  try {
+                    originalLoadEnd === null || originalLoadEnd === void 0 ? void 0 : originalLoadEnd.call(xhr_1, event);
+                  } finally {
+                    report();
+                  }
+                };
+                this.onloadend = handler_1;
+              }
+              send.call(this, body);
+            };
+          };
+          return FTDefaultAutoTracking2;
+        })()
+      );
+      exports.FTDefaultAutoTracking = FTDefaultAutoTracking;
+      function nowNs() {
+        return Date.now() * 1e6;
+      }
+      var resourceSequence = 0;
+      function resourceKey() {
+        resourceSequence = (resourceSequence + 1) % Number.MAX_SAFE_INTEGER;
+        return "cocos-".concat(Date.now().toString(36), "-").concat(resourceSequence.toString(36));
+      }
+      function createHeaders(source) {
+        var HeadersConstructor = globalThis.Headers;
+        if (HeadersConstructor)
+          return new HeadersConstructor(source);
+        var result = {};
+        if (Array.isArray(source)) {
+          source.forEach(function(_a) {
+            var name = _a[0], value = _a[1];
+            result[name] = String(value);
+          });
+        } else if (source && typeof source.forEach === "function") {
+          source.forEach(function(value, name) {
+            result[name] = value;
+          });
+        } else if (source) {
+          forEachOwn(source, function(name, value) {
+            result[name] = String(value);
+          });
+        }
+        return result;
+      }
+      function setHeader(headers, name, value) {
+        if (typeof headers.set === "function")
+          headers.set(name, value);
+        else
+          headers[name] = value;
+      }
+      function headersToObject(headers) {
+        var result = {};
+        if (typeof headers.forEach === "function") {
+          headers.forEach(function(value, key) {
+            result[key] = value;
+          });
+        } else {
+          forEachOwn(headers, function(key, value) {
+            result[key] = value;
+          });
+        }
+        return result;
+      }
+      function forEachOwn(value, callback) {
+        Object.keys(value).forEach(function(key) {
+          return callback(key, value[key]);
+        });
+      }
+      function parseXhrHeaders(raw) {
+        var result = {};
+        raw.trim().split(/[\r\n]+/).forEach(function(line) {
+          var index = line.indexOf(":");
+          if (index > 0)
+            result[line.slice(0, index).trim()] = line.slice(index + 1).trim();
+        });
+        return result;
+      }
+      function stringifyLogValue(value) {
+        if (typeof value === "string")
+          return value;
+        if (value instanceof Error)
+          return "".concat(value.message, "\n").concat(value.stack || "");
+        try {
+          return JSON.stringify(value);
+        } catch (_a) {
+          return String(value);
+        }
+      }
+    }
+  });
+
+  // packages/cocos/dist/creator2/core/validation.js
+  var require_validation = __commonJS({
+    "packages/cocos/dist/creator2/core/validation.js": function(exports) {
+      "use strict";
+      var __assign = exports && exports.__assign || function() {
+        __assign = Object.assign || function(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+          }
+          return t;
+        };
+        return __assign.apply(this, arguments);
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.samplingRate = samplingRate;
+      exports.samplingPercentage = samplingPercentage;
+      exports.validatedSamplingConfig = validatedSamplingConfig;
+      exports.requireText = requireText;
+      function samplingRate(value, name) {
+        if (value === void 0)
+          return void 0;
+        if (!Number.isFinite(value) || value < 0 || value > 1) {
+          throw new RangeError("".concat(name, " must be between 0 and 1"));
+        }
+        return value;
+      }
+      function samplingPercentage(value, name) {
+        if (value === void 0)
+          return void 0;
+        if (!Number.isFinite(value) || value < 0 || value > 100) {
+          throw new RangeError("".concat(name, " must be between 0 and 100"));
+        }
+        return value;
+      }
+      function validatedSamplingConfig(config, scope, fields) {
+        var result = __assign({}, config);
+        fields.forEach(function(_a) {
+          var percentageField = _a[0], legacyField = _a[1];
+          var percentage = result[percentageField];
+          if (percentage !== void 0) {
+            samplingPercentage(percentage, "".concat(scope, ".").concat(percentageField));
+            delete result[legacyField];
+            return;
+          }
+          samplingRate(result[legacyField], "".concat(scope, ".").concat(legacyField));
+        });
+        return result;
+      }
+      function requireText(value, name) {
+        if (!value.trim())
+          throw new TypeError("".concat(name, " must not be empty"));
+        return value;
+      }
+    }
+  });
+
+  // packages/cocos/dist/creator2/core/version.js
+  var require_version = __commonJS({
+    "packages/cocos/dist/creator2/core/version.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FT_COCOS_SDK_BRIDGE_INFO = exports.FT_COCOS_SDK_BRIDGE_INFO_KEY = exports.FT_COCOS_SDK_VERSION_KEY = exports.FT_COCOS_SDK_VERSION = void 0;
+      exports.FT_COCOS_SDK_VERSION = "0.1.1-alpha.2";
+      exports.FT_COCOS_SDK_VERSION_KEY = "sdk_package_cocos";
+      exports.FT_COCOS_SDK_BRIDGE_INFO_KEY = "sdk_bridge_info";
+      exports.FT_COCOS_SDK_BRIDGE_INFO = JSON.stringify({
+        cocos: exports.FT_COCOS_SDK_VERSION
+      });
+    }
+  });
+
+  // packages/cocos/dist/creator2/core/modules.js
+  var require_modules = __commonJS({
+    "packages/cocos/dist/creator2/core/modules.js": function(exports) {
+      "use strict";
+      var __assign = exports && exports.__assign || function() {
+        __assign = Object.assign || function(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+          }
+          return t;
+        };
+        return __assign.apply(this, arguments);
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FTTrace = exports.FTLogger = exports.FTRUM = exports.FTMobileAgent = exports.FTSDKOwnership = void 0;
+      var validation_js_1 = require_validation();
+      var version_js_1 = require_version();
+      var FTSDKOwnership = (
+        /** @class */
+        (function() {
+          function FTSDKOwnership2() {
+            this.mode = "unclaimed";
+          }
+          FTSDKOwnership2.prototype.claimStandalone = function() {
+            if (this.mode === "native-host") {
+              throw new Error("The native host owns SDK initialization in Hybrid mode");
+            }
+            this.mode = "standalone";
+          };
+          FTSDKOwnership2.prototype.claimNativeHost = function() {
+            if (this.mode === "standalone") {
+              throw new Error("Standalone initialization and native-host attachment are mutually exclusive");
+            }
+            this.mode = "native-host";
+          };
+          FTSDKOwnership2.prototype.releaseNativeHost = function() {
+            if (this.mode === "native-host")
+              this.mode = "unclaimed";
+          };
+          FTSDKOwnership2.prototype.releaseStandalone = function() {
+            if (this.mode === "standalone")
+              this.mode = "unclaimed";
+          };
+          FTSDKOwnership2.prototype.assertNativeHostDoesNotOwnSDK = function() {
+            if (this.mode === "native-host") {
+              throw new Error("The native host owns the native SDK in Hybrid mode");
+            }
+          };
+          return FTSDKOwnership2;
+        })()
+      );
+      exports.FTSDKOwnership = FTSDKOwnership;
+      function compact(value) {
+        var source = value;
+        var result = {};
+        Object.keys(value).forEach(function(key) {
+          if (source[key] !== void 0)
+            result[key] = source[key];
+        });
+        return result;
+      }
+      function withBridgeInfo(attributes) {
+        var _a;
+        return __assign((_a = {}, _a[version_js_1.FT_COCOS_SDK_BRIDGE_INFO_KEY] = version_js_1.FT_COCOS_SDK_BRIDGE_INFO, _a), attributes || {});
+      }
+      var FTMobileAgent = (
+        /** @class */
+        (function() {
+          function FTMobileAgent2(transport, ownership) {
+            if (ownership === void 0) {
+              ownership = new FTSDKOwnership();
+            }
+            this.transport = transport;
+            this.ownership = ownership;
+          }
+          FTMobileAgent2.prototype.start = function(config) {
+            var _a;
+            if (!config.datakitUrl && !(config.datawayUrl && config.clientToken)) {
+              throw new TypeError("Configure datakitUrl or datawayUrl with clientToken");
+            }
+            this.ownership.claimStandalone();
+            this.transport.invoke("sdk.configure", compact(__assign(__assign({}, config), { globalContext: __assign(__assign({}, config.globalContext || {}), (_a = {}, _a[version_js_1.FT_COCOS_SDK_VERSION_KEY] = version_js_1.FT_COCOS_SDK_VERSION, _a)) })));
+          };
+          FTMobileAgent2.prototype.bindUser = function(user) {
+            this.transport.invoke("sdk.bindUser", typeof user === "string" ? { userId: (0, validation_js_1.requireText)(user, "userId") } : user);
+          };
+          FTMobileAgent2.prototype.unbindUser = function() {
+            this.transport.invoke("sdk.unbindUser");
+          };
+          FTMobileAgent2.prototype.shutdown = function() {
+            this.ownership.assertNativeHostDoesNotOwnSDK();
+            this.transport.invoke("sdk.shutdown");
+            this.ownership.releaseStandalone();
+          };
+          return FTMobileAgent2;
+        })()
+      );
+      exports.FTMobileAgent = FTMobileAgent;
+      var FTRUM = (
+        /** @class */
+        (function() {
+          function FTRUM2(transport, ownership) {
+            if (ownership === void 0) {
+              ownership = new FTSDKOwnership();
+            }
+            this.transport = transport;
+            this.ownership = ownership;
+          }
+          FTRUM2.prototype.start = function(config) {
+            var payload = (0, validation_js_1.validatedSamplingConfig)(config, "rum", [
+              ["sessionSamplingRate", "sampleRate"],
+              ["sessionOnErrorSamplingRate", "sessionOnErrorSampleRate"]
+            ]);
+            this.ownership.claimStandalone();
+            this.transport.invoke("rum.configure", compact(payload));
+          };
+          FTRUM2.prototype.startView = function(name, attributes) {
+            this.transport.invoke("rum.startView", {
+              name: (0, validation_js_1.requireText)(name, "view name"),
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.stopView = function(attributes) {
+            this.transport.invoke("rum.stopView", { attributes: withBridgeInfo(attributes) });
+          };
+          FTRUM2.prototype.addAction = function(name, type, attributes) {
+            if (type === void 0) {
+              type = "click";
+            }
+            this.transport.invoke("rum.addAction", {
+              name: (0, validation_js_1.requireText)(name, "action name"),
+              type: (0, validation_js_1.requireText)(type, "action type"),
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.startAction = function(name, type, attributes) {
+            if (type === void 0) {
+              type = "click";
+            }
+            this.transport.invoke("rum.startAction", {
+              name: (0, validation_js_1.requireText)(name, "action name"),
+              type: (0, validation_js_1.requireText)(type, "action type"),
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.addError = function(message, stack, type, state, attributes) {
+            if (type === void 0) {
+              type = "cocos_error";
+            }
+            if (state === void 0) {
+              state = "run";
+            }
+            this.transport.invoke("rum.addError", {
+              message: message,
+              stack: stack,
+              type: type,
+              state: state,
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.addLongTask = function(stack, durationNs, attributes) {
+            this.transport.invoke("rum.addLongTask", {
+              stack: stack,
+              durationNs: durationNs,
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.startResource = function(key, attributes) {
+            this.transport.invoke("rum.startResource", {
+              key: (0, validation_js_1.requireText)(key, "resource key"),
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.stopResource = function(key, attributes) {
+            this.transport.invoke("rum.stopResource", {
+              key: (0, validation_js_1.requireText)(key, "resource key"),
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.addResource = function(key, content, metrics) {
+            this.transport.invoke("rum.addResource", {
+              key: (0, validation_js_1.requireText)(key, "resource key"),
+              content: content,
+              metrics: metrics
+            });
+          };
+          return FTRUM2;
+        })()
+      );
+      exports.FTRUM = FTRUM;
+      var FTLogger = (
+        /** @class */
+        (function() {
+          function FTLogger2(transport, ownership) {
+            if (ownership === void 0) {
+              ownership = new FTSDKOwnership();
+            }
+            this.transport = transport;
+            this.ownership = ownership;
+          }
+          FTLogger2.prototype.start = function(config) {
+            var payload = (0, validation_js_1.validatedSamplingConfig)(config, "logger", [
+              ["logSamplingRate", "sampleRate"]
+            ]);
+            this.ownership.claimStandalone();
+            this.transport.invoke("logger.configure", compact(payload));
+          };
+          FTLogger2.prototype.log = function(content, level, attributes) {
+            if (level === void 0) {
+              level = "info";
+            }
+            this.transport.invoke("logger.log", {
+              content: content,
+              level: level,
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          return FTLogger2;
+        })()
+      );
+      exports.FTLogger = FTLogger;
+      var FTTrace = (
+        /** @class */
+        (function() {
+          function FTTrace2(transport, ownership) {
+            if (ownership === void 0) {
+              ownership = new FTSDKOwnership();
+            }
+            this.transport = transport;
+            this.ownership = ownership;
+          }
+          FTTrace2.prototype.start = function(config) {
+            var payload = (0, validation_js_1.validatedSamplingConfig)(config, "trace", [
+              ["traceSamplingRate", "sampleRate"]
+            ]);
+            this.ownership.claimStandalone();
+            this.transport.invoke("trace.configure", compact(payload));
+          };
+          FTTrace2.prototype.getHeaders = function(url, resourceKey) {
+            return this.transport.invoke("trace.getHeaders", {
+              url: (0, validation_js_1.requireText)(url, "url"),
+              resourceKey: resourceKey
+            }) || {};
+          };
+          return FTTrace2;
+        })()
+      );
+      exports.FTTrace = FTTrace;
+    }
+  });
+
+  // packages/cocos/dist/creator2/core/client.js
+  var require_client = __commonJS({
+    "packages/cocos/dist/creator2/core/client.js": function(exports) {
+      "use strict";
+      var __assign = exports && exports.__assign || function() {
+        __assign = Object.assign || function(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+          }
+          return t;
+        };
+        return __assign.apply(this, arguments);
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FTCocosSDK = void 0;
+      var modules_js_1 = require_modules();
+      var version_js_1 = require_version();
+      var FTCocosSDK = (
+        /** @class */
+        (function() {
+          function FTCocosSDK2(transport, autoTracking, engine) {
+            if (engine === void 0) {
+              engine = "creator3";
+            }
+            this.transport = transport;
+            this.autoTracking = autoTracking;
+            this.engine = engine;
+            this.extensionProtocol = 1;
+            this.state = "idle";
+            this.hybridAutoTracking = {};
+            this.ownership = new modules_js_1.FTSDKOwnership();
+            this.mobile = new modules_js_1.FTMobileAgent(transport, this.ownership);
+            this.rum = new modules_js_1.FTRUM(transport, this.ownership);
+            this.logger = new modules_js_1.FTLogger(transport, this.ownership);
+            this.trace = new modules_js_1.FTTrace(transport, this.ownership);
+          }
+          Object.defineProperty(FTCocosSDK2.prototype, "lifecycleMode", {
+            /** @internal Ownership state used by the platform facade. */
+            get: function() {
+              return this.state === "standalone" ? "standalone" : this.state === "hybrid-attached" || this.state === "hybrid-entered" ? "hybrid" : "idle";
+            },
+            enumerable: false,
+            configurable: true
+          });
+          Object.defineProperty(FTCocosSDK2.prototype, "isCocosEntered", {
+            get: function() {
+              return this.state === "standalone" || this.state === "hybrid-entered";
+            },
+            enumerable: false,
+            configurable: true
+          });
+          FTCocosSDK2.prototype.registerExtension = function(id, version, engine, factory) {
+            if (version !== version_js_1.FT_COCOS_SDK_VERSION || engine !== this.engine) {
+              throw new Error("SDK extension version or Creator engine does not match the base SDK");
+            }
+            if (this.extension) {
+              if (id !== this.extensionId)
+                throw new Error("A different SDK extension is already installed");
+              return this.extension.value;
+            }
+            if (this.state !== "idle")
+              throw new Error("Install SDK extensions before start() or attach()");
+            var extension = factory();
+            this.extension = extension;
+            this.extensionId = id;
+            return extension.value;
+          };
+          FTCocosSDK2.prototype.start = function(config) {
+            var _a, _b, _c, _d, _e, _f, _g;
+            rejectReplayConfig(config);
+            if (this.state !== "idle") {
+              throw new Error("start() and attach() are mutually exclusive");
+            }
+            (_c = (_a = this.extension) === null || _a === void 0 ? void 0 : (_b = _a.lifecycle).beforeStart) === null || _c === void 0 ? void 0 : _c.call(_b);
+            this.mobile.start(config.sdk);
+            this.state = "standalone";
+            if (config.rum)
+              this.rum.start(config.rum);
+            if (config.logger)
+              this.logger.start(config.logger);
+            if (config.trace)
+              this.trace.start(config.trace);
+            (_f = (_d = this.extension) === null || _d === void 0 ? void 0 : (_e = _d.lifecycle).afterStart) === null || _f === void 0 ? void 0 : _f.call(_e);
+            if (config.autoTrack)
+              (_g = this.autoTracking) === null || _g === void 0 ? void 0 : _g.start(config.autoTrack);
+          };
+          FTCocosSDK2.prototype.attach = function(config) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+            if (config === void 0) {
+              config = {};
+            }
+            rejectReplayConfig(config);
+            if (this.state === "standalone") {
+              throw new Error("start() and attach() are mutually exclusive");
+            }
+            if (this.state === "hybrid-attached" || this.state === "hybrid-entered")
+              return;
+            this.ownership.claimNativeHost();
+            try {
+              (_c = (_a = this.extension) === null || _a === void 0 ? void 0 : (_b = _a.lifecycle).beforeAttach) === null || _c === void 0 ? void 0 : _c.call(_b);
+              this.transport.invoke("hybrid.attach", {
+                sdkVersion: version_js_1.FT_COCOS_SDK_VERSION
+              });
+              if ((_d = config.autoTrack) === null || _d === void 0 ? void 0 : _d.network) {
+                (_e = this.autoTracking) === null || _e === void 0 ? void 0 : _e.start({ network: true }, void 0, "network");
+              }
+            } catch (error) {
+              try {
+                (_f = this.autoTracking) === null || _f === void 0 ? void 0 : _f.stop("network");
+              } catch (_o) {
+              }
+              try {
+                (_j = (_g = this.extension) === null || _g === void 0 ? void 0 : (_h = _g.lifecycle).rollbackAttach) === null || _j === void 0 ? void 0 : _j.call(_h);
+              } catch (_p) {
+              }
+              if (this.state === "hybrid-detached") {
+                try {
+                  (_m = (_k = this.extension) === null || _k === void 0 ? void 0 : (_l = _k.lifecycle).detach) === null || _m === void 0 ? void 0 : _m.call(_l);
+                } catch (_q) {
+                }
+              } else {
+                this.ownership.releaseNativeHost();
+              }
+              throw error;
+            }
+            this.hybridAutoTracking = __assign({}, config.autoTrack || {});
+            this.state = "hybrid-attached";
+          };
+          FTCocosSDK2.prototype.enterCocos = function(options) {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            if (options === void 0) {
+              options = {};
+            }
+            if (this.state === "standalone") {
+              throw new Error("enterCocos() is only available after attach()");
+            }
+            if (this.state === "idle" || this.state === "hybrid-detached") {
+              throw new Error("Call attach() before enterCocos()");
+            }
+            if (this.state === "hybrid-entered")
+              return;
+            var viewName = nonEmptyText(options.viewName);
+            if (!this.hybridAutoTracking.scenes && !viewName) {
+              throw new TypeError("enterCocos.viewName is required when scene tracking is disabled");
+            }
+            try {
+              (_c = (_a = this.extension) === null || _a === void 0 ? void 0 : (_b = _a.lifecycle).enter) === null || _c === void 0 ? void 0 : _c.call(_b);
+              (_d = this.autoTracking) === null || _d === void 0 ? void 0 : _d.start(this.hybridAutoTracking, viewName, "page");
+              this.state = "hybrid-entered";
+            } catch (error) {
+              try {
+                (_e = this.autoTracking) === null || _e === void 0 ? void 0 : _e.stop("page");
+              } catch (_j) {
+              }
+              try {
+                (_h = (_f = this.extension) === null || _f === void 0 ? void 0 : (_g = _f.lifecycle).leave) === null || _h === void 0 ? void 0 : _h.call(_g);
+              } catch (_k) {
+              }
+              throw error;
+            }
+          };
+          FTCocosSDK2.prototype.leaveCocos = function() {
+            var _a, _b, _c, _d;
+            if (this.state === "standalone") {
+              throw new Error("leaveCocos() is only available after attach()");
+            }
+            if (this.state !== "hybrid-entered")
+              return;
+            try {
+              (_a = this.autoTracking) === null || _a === void 0 ? void 0 : _a.stop("page");
+            } finally {
+              (_d = (_b = this.extension) === null || _b === void 0 ? void 0 : (_c = _b.lifecycle).leave) === null || _d === void 0 ? void 0 : _d.call(_c);
+              this.state = "hybrid-attached";
+            }
+          };
+          FTCocosSDK2.prototype.detach = function() {
+            var _this = this;
+            var _a, _b, _c;
+            if (this.state === "standalone")
+              throw new Error("detach() is only available after attach()");
+            if (this.state === "idle" || this.state === "hybrid-detached")
+              return;
+            var failure;
+            var cleanup = function(operation) {
+              try {
+                operation();
+              } catch (error) {
+                if (failure === void 0)
+                  failure = error;
+              }
+            };
+            cleanup(function() {
+              return _this.leaveCocos();
+            });
+            cleanup(function() {
+              var _a2;
+              return (_a2 = _this.autoTracking) === null || _a2 === void 0 ? void 0 : _a2.stop();
+            });
+            if (failure !== void 0)
+              throw failure;
+            (_c = (_a = this.extension) === null || _a === void 0 ? void 0 : (_b = _a.lifecycle).detach) === null || _c === void 0 ? void 0 : _c.call(_b);
+            this.hybridAutoTracking = {};
+            this.state = "hybrid-detached";
+          };
+          FTCocosSDK2.prototype.shutdown = function() {
+            var _this = this;
+            if (this.state === "hybrid-attached" || this.state === "hybrid-entered" || this.state === "hybrid-detached") {
+              throw new Error("The native host owns the native SDK; call leaveCocos() instead of shutdown()");
+            }
+            if (this.state === "idle")
+              return;
+            var failure;
+            var cleanup = function(operation) {
+              try {
+                operation();
+              } catch (error) {
+                if (failure === void 0)
+                  failure = error;
+              }
+            };
+            cleanup(function() {
+              var _a;
+              return (_a = _this.autoTracking) === null || _a === void 0 ? void 0 : _a.stop();
+            });
+            cleanup(function() {
+              var _a, _b, _c;
+              return (_c = (_a = _this.extension) === null || _a === void 0 ? void 0 : (_b = _a.lifecycle).shutdown) === null || _c === void 0 ? void 0 : _c.call(_b);
+            });
+            cleanup(function() {
+              _this.mobile.shutdown();
+              _this.state = "idle";
+            });
+            if (failure !== void 0)
+              throw failure;
+          };
+          return FTCocosSDK2;
+        })()
+      );
+      exports.FTCocosSDK = FTCocosSDK;
+      function nonEmptyText(value) {
+        return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+      }
+      function rejectReplayConfig(config) {
+        if ("replay" in config) {
+          throw new Error("Session Replay requires @cloudcare/cocos-session-replay. Install the package and use withSessionReplay() before passing replay configuration.");
+        }
+      }
+    }
+  });
+
+  // packages/cocos/dist/creator2/core/transport.js
+  var require_transport = __commonJS({
+    "packages/cocos/dist/creator2/core/transport.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FTNoopTransport = void 0;
+      exports.parseTransportResponse = parseTransportResponse;
+      var FTNoopTransport = (
+        /** @class */
+        (function() {
+          function FTNoopTransport2() {
+            this.platform = "unsupported";
+          }
+          FTNoopTransport2.prototype.invoke = function(_method, _payload) {
+            return void 0;
+          };
+          return FTNoopTransport2;
+        })()
+      );
+      exports.FTNoopTransport = FTNoopTransport;
+      function parseTransportResponse(raw) {
+        if (raw === void 0 || raw === null || raw === "")
+          return void 0;
+        var response = raw;
+        if (typeof raw === "string") {
+          response = JSON.parse(raw);
+        }
+        if (!isResponse(response)) {
+          return response;
+        }
+        if (!response.ok) {
+          throw new Error(response.error || "Native bridge call failed");
+        }
+        return response.value;
+      }
+      function isResponse(value) {
+        return typeof value === "object" && value !== null && "ok" in value;
+      }
+    }
+  });
+
+  // packages/cocos/dist/creator2/core/platform-runtime.js
+  var require_platform_runtime = __commonJS({
+    "packages/cocos/dist/creator2/core/platform-runtime.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.platformGlobal = platformGlobal;
+      exports.existingPlatformImplementation = existingPlatformImplementation;
+      exports.platformImplementation = platformImplementation;
+      var version_js_1 = require_version();
+      function platformGlobal() {
+        return typeof window !== "undefined" ? window : globalThis;
+      }
+      function existingPlatformImplementation(context, target) {
+        var _a;
+        if (target === void 0) {
+          target = platformGlobal();
+        }
+        var previous = (_a = target.__FT_COCOS_INSTANCES__) === null || _a === void 0 ? void 0 : _a[context.engine + ":" + context.platform];
+        if (previous && previous.version !== version_js_1.FT_COCOS_SDK_VERSION)
+          throw new Error("Cocos SDK versions must match on the same page");
+        return previous === null || previous === void 0 ? void 0 : previous.sdk;
+      }
+      function platformImplementation(context, target, create) {
+        if (target === void 0) {
+          target = platformGlobal();
+        }
+        var key = context.engine + ":" + context.platform;
+        var instances = target.__FT_COCOS_INSTANCES__ || (target.__FT_COCOS_INSTANCES__ = {});
+        var previous = existingPlatformImplementation(context, target);
+        if (previous)
+          return previous;
+        var factory = context.platform === "web" ? target.__FT_COCOS_WEB_FACTORY__ : target.__FT_COCOS_NATIVE_FACTORY__;
+        if (!create && (!factory || factory.protocol !== 1 || factory.version !== version_js_1.FT_COCOS_SDK_VERSION)) {
+          throw new Error(context.platform === "web" ? "Cocos Web runtime is missing or incompatible. Run the installer with --web and rebuild, or load /web/bootstrap before game scripts." : "Cocos native runtime is missing or incompatible. Rerun the SDK installer and rebuild the project.");
+        }
+        var sdk = create ? create() : factory.create(context, target);
+        instances[key] = { version: version_js_1.FT_COCOS_SDK_VERSION, sdk: sdk };
+        return sdk;
+      }
+    }
+  });
+
+  // packages/cocos/dist/creator2/native/bootstrap.js
+  var require_bootstrap = __commonJS({
+    "packages/cocos/dist/creator2/native/bootstrap.js": function(exports) {
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var auto_tracking_js_1 = require_auto_tracking();
+      var client_js_1 = require_client();
+      var modules_js_1 = require_modules();
+      var transport_js_1 = require_transport();
+      var platform_runtime_js_1 = require_platform_runtime();
+      var version_js_1 = require_version();
+      (0, platform_runtime_js_1.platformGlobal)().__FT_COCOS_NATIVE_FACTORY__ = {
+        protocol: 1,
+        version: version_js_1.FT_COCOS_SDK_VERSION,
+        create: function(context) {
+          if (context.platform === "web")
+            throw new Error("Native runtime cannot serve a Web application");
+          var transport = {
+            platform: context.platform,
+            invoke: function(method, payload) {
+              if (context.platform === "unsupported")
+                return void 0;
+              if (!context.reflection)
+                throw new Error("Cocos native reflection is unavailable");
+              var json = payload === void 0 ? "{}" : JSON.stringify(payload);
+              var raw = context.platform === "android" ? context.reflection.callStaticMethod("com/ft/sdk/cocos/FTCocosBridge", "invoke", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;", method, json) : context.reflection.callStaticMethod("FTCocosBridge", "invoke:payload:", method, json);
+              return (0, transport_js_1.parseTransportResponse)(raw);
+            }
+          };
+          var tracking = new auto_tracking_js_1.FTDefaultAutoTracking(new modules_js_1.FTRUM(transport), new modules_js_1.FTLogger(transport), new modules_js_1.FTTrace(transport), context.hooks);
+          return new client_js_1.FTCocosSDK(transport, tracking, context.engine);
+        }
+      };
+    }
+  });
+  require_bootstrap();
+})();