nitro-core 0.0.0 → 0.37.2-nightly.32.gcd7b91624dde

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2024 Marc Rousavy
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# nitro-core
+
+Nitro's shared runtime sources and JavaScript API.
+
+The package contains native sources in `native/{cpp,apple,android}/`, TypeScript
+sources in `js/src/`, and compiled JavaScript and declarations in `js/lib/`.
+Native sources and JS use the same package version. Core has no React Native
+dependency. Views, TurboModules, and React Native dispatchers live in
+`react-native-nitro-modules`, which stages Core sources for CocoaPods and Android
+builds.
+
+```ts
+import type { HybridObject } from 'nitro-core'
+
+export interface Image extends HybridObject<{ ios: 'swift', android: 'kotlin' }> {
+  readonly width: number
+  readonly height: number
+}
+```
+
+The package includes `HybridObject`, platform and custom type definitions,
+`NitroModulesProxy`, and helpers such as `getHybridObjectConstructor`.
+Nitrogen reads these definitions when generating native bindings.
+
+Importing the package does not install Nitro or require a native runtime.
+The host integration installs the native proxy and dispatcher, checks its
+version, then calls `getNitroModules()` to initialize the exported
+`NitroModules` binding. The binding is the native object itself.
+Call `getInstalledNitro()` to check whether the current runtime has a proxy.
+
+Each loaded module instance has its own `NitroModules` binding. Code loaded
+independently, including a separate CommonJS or ESM copy, should call
+`getNitroModules()` to initialize its binding and access the runtime's native
+proxy.
+
+React Native applications should initialize Nitro through
+`react-native-nitro-modules`, which re-exports these APIs and handles native
+installation and worklets support:
+
+```ts
+import { NitroModules, type HybridObject } from 'react-native-nitro-modules'
+```
+
+Keep `nitro-core`, Nitrogen, and the host integration on the same release version.
+The host integration package supplies platform build integration and stages the
+native sources from its exact `nitro-core` dependency. Staged files are generated;
+Core implementation changes belong in this package. React Native adapter changes
+belong in `react-native-nitro-modules`.
+
+The React Native entry resolves to compiled JavaScript. After editing this
+package, run `bun run build` before rebuilding an app. Validate native changes
+in both `tests/standalone` and `tests/react-native` in this repository.

package/js/lib/commonjs/AnyHybridObject.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AnyHybridObject.js.map

package/js/lib/commonjs/AnyHybridObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnyHybridObject.js","sourceRoot":"","sources":["../../src/AnyHybridObject.ts"],"names":[],"mappings":"","sourcesContent":["import type { HybridObject } from './HybridObject.js'\n\n/**\n * Represents a value of the base `HybridObject` type all other\n * HybridObjects inherit from.\n * This is not type-checked to an actual `HybridObject` (boxed).\n */\nexport interface AnyHybridObject extends HybridObject<{}> {\n  __anyHybridObjectTag?: never\n}\n"]}

package/js/lib/commonjs/AnyMap.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AnyMap.js.map

package/js/lib/commonjs/AnyMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnyMap.js","sourceRoot":"","sources":["../../src/AnyMap.ts"],"names":[],"mappings":"","sourcesContent":["import type { Int64 } from './Int64.js'\n\n/**\n * Represents a single value inside an untyped map.\n */\nexport type ValueType =\n  | string\n  | number\n  | boolean\n  | Int64\n  | null\n  | ValueType[]\n  | { [k: string]: ValueType }\n\n/**\n * Represents an untyped map, similar to a JSON structure.\n * Supported types:\n * - Primitives (`string`, `number`, `boolean`, `Int64`, `null`)\n * - Arrays of primitives (`ValueType[]`)\n * - Objects of primitives (`Record<string, ValueType>`)\n * - Arrays of arrays or objects\n * - Objects of arrays or objects\n *\n * @note It is recommended to always use typed `interface`s instead of `AnyMap` for\n * both type safety, as well as better performance.\n */\nexport type AnyMap = Record<string, ValueType>\n"]}

package/js/lib/commonjs/BoxedHybridObject.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=BoxedHybridObject.js.map

package/js/lib/commonjs/BoxedHybridObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoxedHybridObject.js","sourceRoot":"","sources":["../../src/BoxedHybridObject.ts"],"names":[],"mappings":"","sourcesContent":["import type { HybridObject } from './HybridObject.js'\n\n/**\n * Represents a boxed {@linkcode HybridObject} that can later be unboxed again.\n * This is implemented as a `jsi::HostObject`.\n */\nexport interface BoxedHybridObject<T extends HybridObject<{}>> {\n  /**\n   * Unboxes the {@linkcode HybridObject}.\n   * This can be called from a different Runtime than the one it was boxed in.\n   */\n  unbox(): T\n}\n"]}

package/js/lib/commonjs/CustomType.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=CustomType.js.map

package/js/lib/commonjs/CustomType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomType.js","sourceRoot":"","sources":["../../src/CustomType.ts"],"names":[],"mappings":"","sourcesContent":["export interface CustomTypeConfig {\n  /**\n   * Represents the name of the C++ header that will be included\n   * to support your type.\n   *\n   * This C++ header should be written by you, and findable within\n   * the user-search-paths so it can be included.\n   */\n  include: string\n  /**\n   * A flag that enables const-reference passing for heavy types\n   * to prevent unnecessary copies.\n   * When `true`, the type will be passed to clients as a `const T&` instead of just `T`.\n   * @default false\n   */\n  canBePassedByReference?: boolean\n}\n\n/**\n * Represents a custom, manually written native type.\n * - {@linkcode TypeName}: Represents the name of the C++ type (class, struct, alias).\n * - {@linkcode Config}: Configures how the C++ type is included, used, and typed.\n *\n * **You** then need to create a header file that is importable with the filename specified in {@linkcode Config.include}.\n * @example\n * ```ts\n * type MyOwnString = CustomType<string, 'MyOwnString', { include: 'MyOwnString.hpp' }>\n * interface MyHybrid extends HybridObject<{ … }> {\n *   getValue(): MyOwnString\n * }\n * ```\n * The C++ header will always be included by Nitro as a user-search-path header, that is;\n * ```cpp\n * #include \"MyOwnString.hpp\"\n * ```\n * The C++ header (`MyOwnString.hpp`) then needs to define the type `MyOwnString`\n * within the namespace of your Nitro Module (`namespace margelo::nitro::...`),\n * and an overload for `JSIConverter<MyOwnString>` within the Nitro core namespace\n * (`namespace margelo::nitro`):\n * ```cpp\n * namespace margelo::nitro::test {\n *   using MyOwnString = std::string;\n * }\n * namespace margelo::nitro {\n *   template<>\n *   struct JSIConverter<test::MyOwnString> final {\n *     static test::MyOwnString fromJSI(jsi::Runtime&, const jsi::Value&);\n *     static jsi::Value toJSI(jsi::Runtime&, test::MyOwnString);\n *     static bool canConvert(jsi::Runtime&, const jsi::Value& value);\n *   }\n * }\n * ```\n */\nexport type CustomType<\n  T,\n  TypeName extends string,\n  Config extends CustomTypeConfig,\n> = T & {\n  readonly __customTypeName?: TypeName\n  readonly __customTypeConfig?: Config\n}\n"]}

package/js/lib/commonjs/HybridObject.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=HybridObject.js.map

package/js/lib/commonjs/HybridObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HybridObject.js","sourceRoot":"","sources":["../../src/HybridObject.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Describes the languages this component will be implemented in.\n *\n * By default, everything has a C++ base, and can optionally be bridged down\n * to platform-specific languages like Swift or Kotlin\n */\nexport interface PlatformSpec {\n  ios?: 'c++' | 'swift'\n  android?: 'c++' | 'kotlin'\n}\n\n/**\n * Represents a Nitro `HybridObject` which is implemented in a native language like\n * C++, Swift or Kotlin.\n * Every Nitro `HybridObject` has a C++ base, and can optionally be bridged down to Swift or Kotlin.\n *\n * `HybridObject`s use the Nitro Tunnel for efficient, low-overhead JS <-> Native communication.\n *\n * All `HybridObject`s are implemented using `NativeState`, and inherit their properties\n * and methods from their prototype, so the actual JS object is empty.\n *\n * @type Platforms: The type of platforms this HybridObject will be implemented in.\n * @example\n * ```ts\n * interface Photo extends HybridObject<{ ios: 'swift', android: 'kotlin' }> {\n *   readonly width: number\n *   readonly height: number\n *   toArrayBuffer(): ArrayBuffer\n *   saveToFile(path: string): Promise<void>\n * }\n * ```\n */\nexport interface HybridObject<Platforms extends PlatformSpec> {\n  /**\n   * Holds a type-name describing the native `HybridObject` instance.\n   *\n   * This is the only property actually present on the actual JavaScript object,\n   * because all other properties and methods are inherited from a shared Prototype.\n   *\n   * Nitro prototypes also have a `__type`.\n   *\n   * - For actual HybridObject instances, this is `HybridObject<...>`\n   * - For prototypes this is `Prototype<...>`.\n   *\n   * @internal\n   * @private\n   * @note This value is available in debug only.\n   */\n  readonly __type?: string\n  /**\n   * The `HybridObject`'s name.\n   */\n  readonly name: string\n  /**\n   * Returns a string representation of the given `HybridObject`.\n   *\n   * Unless overridden by the `HybridObject`, this will return the name of the object.\n   *\n   * @example\n   * ```ts\n   * const hybridA = SomeModule.getExistingHybridInstance()\n   * console.log(hybridA.toString()) // [HybridObject HybridA]\n   * ```\n   */\n  toString(): string\n  /**\n   * Returns whether this `HybridObject` is the same object as {@linkcode other}.\n   *\n   * While two `HybridObject`s might not be equal when compared with `==`, they might still\n   * hold the same underlying `HybridObject`, in which case {@linkcode equals | equals(other)}\n   * will return `true`.\n   *\n   * @example\n   * ```ts\n   * const hybridA = SomeModule.getExistingHybridInstance()\n   * const hybridB = SomeModule.getExistingHybridInstance()\n   * console.log(hybridA.equals(hybridB)) // true\n   * ```\n   */\n  equals(other: HybridObject<Platforms>): boolean\n  /**\n   * Disposes any resources this {@linkcode HybridObject} might hold natively,\n   * and releases this {@linkcode HybridObject}'s `NativeState`.\n   *\n   * After calling {@linkcode dispose()}, this object can no longer be used.\n   *\n   * Eagerly disposing a {@linkcode HybridObject} could be beneficial for a queue-/handler-architecture\n   * where a bunch of Hybrid Objects are allocated, and later deallocated once a callback (e.g. a render function)\n   * completes.\n   *\n   * @note It is **NOT** required to call {@linkcode dispose()} manually, as the JavaScript\n   * Garbage Collector automatically disposes and releases any resources when needed.\n   * It is purely optional to eagerly-, and manually-, call {@linkcode dispose()} here - **use with caution!**\n   */\n  dispose(): void\n}\n"]}

package/js/lib/commonjs/Int64.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Int64.js.map

package/js/lib/commonjs/Int64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Int64.js","sourceRoot":"","sources":["../../src/Int64.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Represents an unsigned 64-bit integer (or \"uint64\").\n */\nexport type UInt64 = bigint & { __unsignedTag?: never }\n\n/**\n * Represents a signed 64-bit integer (or \"int64\").\n */\nexport type Int64 = bigint & { __signedTag?: never }\n"]}

package/js/lib/commonjs/NitroModules.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NitroModules = void 0;
+exports.getInstalledNitro = getInstalledNitro;
+exports.getNitroModules = getNitroModules;
+exports.isRuntimeAlive = isRuntimeAlive;
+require("./globals.js");
+/**
+ * Returns the native proxy, if this JavaScript runtime has installed Nitro.
+ * This does not install Nitro or initialize the {@linkcode NitroModules} binding.
+ */
+function getInstalledNitro() {
+    return globalThis.NitroModulesProxy;
+}
+/**
+ * Returns the installed native proxy and initializes {@linkcode NitroModules}.
+ * The host integration is responsible for installing Nitro first.
+ */
+function getNitroModules() {
+    const nitroModules = getInstalledNitro();
+    if (nitroModules == null) {
+        throw new Error('Nitro is not installed in this JavaScript runtime. Initialize the host integration before using NitroModules.');
+    }
+    exports.NitroModules = nitroModules;
+    return nitroModules;
+}
+/**
+ * Returns whether the runtime still has Nitro's JSI cache and dispatcher.
+ */
+function isRuntimeAlive() {
+    const cache = globalThis.__nitroJsiCache;
+    const dispatcher = globalThis.__nitroDispatcher;
+    return cache != null && dispatcher != null;
+}
+//# sourceMappingURL=NitroModules.js.map

package/js/lib/commonjs/NitroModules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NitroModules.js","sourceRoot":"","sources":["../../src/NitroModules.ts"],"names":[],"mappings":";;;AAgBA,8CAEC;AAMD,0CASC;AAKD,wCAIC;AAzCD,wBAAqB;AAWrB;;;GAGG;AACH,SAAgB,iBAAiB;IAC/B,OAAO,UAAU,CAAC,iBAAkD,CAAA;AACtE,CAAC;AAED;;;GAGG;AACH,SAAgB,eAAe;IAC7B,MAAM,YAAY,GAAG,iBAAiB,EAAE,CAAA;IACxC,IAAI,YAAY,IAAI,IAAI,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CACb,+GAA+G,CAChH,CAAA;IACH,CAAC;IACD,oBAAY,GAAG,YAAY,CAAA;IAC3B,OAAO,YAAY,CAAA;AACrB,CAAC;AAED;;GAEG;AACH,SAAgB,cAAc;IAC5B,MAAM,KAAK,GAAG,UAAU,CAAC,eAAe,CAAA;IACxC,MAAM,UAAU,GAAG,UAAU,CAAC,iBAAiB,CAAA;IAC/C,OAAO,KAAK,IAAI,IAAI,IAAI,UAAU,IAAI,IAAI,CAAA;AAC5C,CAAC","sourcesContent":["import type { NitroModulesProxy } from './NitroModulesProxy.js'\nimport './globals.js'\n\n/**\n * The installed native Nitro entry point.\n *\n * A host integration must call {@linkcode getNitroModules} after installing\n * Nitro into the JavaScript runtime. The binding then refers to that same\n * native object, including its NativeState and prototype.\n */\nexport let NitroModules: NitroModulesProxy\n\n/**\n * Returns the native proxy, if this JavaScript runtime has installed Nitro.\n * This does not install Nitro or initialize the {@linkcode NitroModules} binding.\n */\nexport function getInstalledNitro(): NitroModulesProxy | undefined {\n  return globalThis.NitroModulesProxy as NitroModulesProxy | undefined\n}\n\n/**\n * Returns the installed native proxy and initializes {@linkcode NitroModules}.\n * The host integration is responsible for installing Nitro first.\n */\nexport function getNitroModules(): NitroModulesProxy {\n  const nitroModules = getInstalledNitro()\n  if (nitroModules == null) {\n    throw new Error(\n      'Nitro is not installed in this JavaScript runtime. Initialize the host integration before using NitroModules.'\n    )\n  }\n  NitroModules = nitroModules\n  return nitroModules\n}\n\n/**\n * Returns whether the runtime still has Nitro's JSI cache and dispatcher.\n */\nexport function isRuntimeAlive(): boolean {\n  const cache = globalThis.__nitroJsiCache\n  const dispatcher = globalThis.__nitroDispatcher\n  return cache != null && dispatcher != null\n}\n"]}

package/js/lib/commonjs/NitroModulesProxy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=NitroModulesProxy.js.map

package/js/lib/commonjs/NitroModulesProxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NitroModulesProxy.js","sourceRoot":"","sources":["../../src/NitroModulesProxy.ts"],"names":[],"mappings":"","sourcesContent":["import type { HybridObject } from './HybridObject.js'\nimport type { BoxedHybridObject } from './BoxedHybridObject.js'\n\n/**\n * The native entry point for Nitro Modules in a JavaScript runtime.\n *\n * This is a `HybridObject` on the native side as well, and is expected to be\n * installed into the runtime's `global` by the host integration.\n */\nexport interface NitroModulesProxy extends HybridObject<{\n  ios: 'c++'\n  android: 'c++'\n}> {\n  /**\n   * Create a new instance of the `HybridObject` {@linkcode T}.\n   *\n   * {@linkcode T} has to be registered beforehand under the name {@linkcode name}\n   * in the native Nitro Modules `HybridObjectRegistry`.\n   *\n   * @param name The name of the `HybridObject` under which it was registered at.\n   * @returns An instance of {@linkcode T}\n   * @throws an Error if {@linkcode T} has not been registered under the name {@linkcode name}.\n   */\n  createHybridObject<T extends HybridObject<{}>>(name: string): T\n  /**\n   * Returns whether a HybridObject under the given {@linkcode name} is registered, or not.\n   */\n  hasHybridObject(name: string): boolean\n  /**\n   * Returns whether the given {@linkcode object} is a {@linkcode HybridObject}, or not.\n   */\n  isHybridObject(object: object): object is HybridObject<{}>\n  /**\n   * Get a list of all registered Hybrid Objects.\n   */\n  getAllHybridObjectNames(): string[]\n\n  /**\n   * Gets the current build type configuration as defined in the `NITRO_DEBUG`\n   * preprocessor flag.\n   */\n  buildType: 'debug' | 'release'\n  /**\n   * Gets the native Nitro Modules core runtime version that this app is built with.\n   * This should be kept in sync with the JS version (package.json), otherwise it could\n   * introduce undefined behaviour.\n   */\n  version: string\n\n  /**\n   * Boxes the given {@linkcode hybridObject} into a {@linkcode BoxedHybridObject<T>}, which can\n   * later be unboxed in a separate Runtime.\n   *\n   * While Nitro is runtime-agnostic and all `HybridObject`s can be used from a any Runtime,\n   * some threading/worklet libraries (like [react-native-worklets-core](https://github.com/margelo/react-native-worklets-core))\n   * do not yet support copying over `HybridObject`s as they use newer JSI APIs like `jsi::NativeState`.\n   *\n   * While those APIs are not yet available, you can still use every Nitro Hybrid Object in a separate\n   * Runtime/Worklet context by just boxing it yourself:\n   *\n   * @example\n   * ```ts\n   * const something = NitroModules.createHybridObject<Something>('Something')\n   * const boxed = NitroModules.box(something)\n   * const context = Worklets.createContext('DummyContext')\n   * context.runAsync(() => {\n   *   'worklet'\n   *   const unboxed = boxed.unbox()\n   *   console.log(unboxed.name) // --> \"Something\"\n   * })\n   * ```\n   */\n  box<T extends HybridObject<{}>>(obj: T): BoxedHybridObject<T>\n\n  /**\n   * Returns whether the given {@linkcode object} has NativeState or not.\n   */\n  hasNativeState(object: unknown): boolean\n\n  /**\n   * Re-calculates `memorySize` of the given {@linkcode HybridObject} and notifies\n   * the JS VM about the newly updated memory footprint.\n   *\n   * This is achieved by just doing a round-trip from JS -> native -> JS.\n   */\n  updateMemorySize<T extends HybridObject<{}>>(obj: T): T\n\n  /**\n   * Allocate a new native {@linkcode ArrayBuffer} with the\n   * given {@linkcode size}.\n   *\n   * As opposed to creating an {@linkcode ArrayBuffer} from JS,\n   * this method returns a buffer that can be directly read from\n   * and written to in Nitro Modules without copying, as native\n   * owns it - not JS.\n   */\n  createNativeArrayBuffer(size: number): ArrayBuffer\n\n  /**\n   * Gets a total number of currently allocated {@linkcode HybridObject}s.\n   * @internal\n   */\n  debug_getTotalAllocatedHybridObjects(): number\n}\n"]}

package/js/lib/commonjs/Sync.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Sync.js.map

package/js/lib/commonjs/Sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sync.js","sourceRoot":"","sources":["../../src/Sync.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Marks the given function as _synchronous_, allowing it to be called synchronously on the same\n * Thread.\n *\n * This allows for fast native -> JS calls and avoids any asynchronous dispatching, but requires careful\n * threading considerations.\n */\nexport type Sync<T> = T extends Function ? T & { __syncTag?: never } : never\n"]}

package/js/lib/commonjs/checkNitroVersion.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNitroVersion = assertNitroVersion;
+exports.warnIfNitroVersionMismatch = warnIfNitroVersionMismatch;
+const version_js_1 = require("./version.js");
+/**
+ * Checks compatibility before reusing a proxy installed by another copy of Nitro.
+ */
+function assertNitroVersion(nitroModules) {
+    if (nitroModules.version !== version_js_1.version) {
+        throw new Error(`Nitro was installed twice: once with native version ${nitroModules.version} and once with JS version ${version_js_1.version}. ` +
+            'This usually means different versions of Nitro exist in node_modules (e.g. in monorepos or double-linked setups).');
+    }
+}
+/**
+ * Warns when the installed native runtime differs from this JavaScript package.
+ * Host integrations should call this in development after installing Nitro.
+ */
+function warnIfNitroVersionMismatch(nitroModules) {
+    if (nitroModules.version !== version_js_1.version) {
+        console.warn(`The native Nitro Modules core runtime version is ${nitroModules.version}, but the JS code is using version ${version_js_1.version}. ` +
+            'This could lead to undefined behaviour! Make sure to keep your Nitro versions in sync.');
+    }
+}
+//# sourceMappingURL=checkNitroVersion.js.map

package/js/lib/commonjs/checkNitroVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkNitroVersion.js","sourceRoot":"","sources":["../../src/checkNitroVersion.ts"],"names":[],"mappings":";;AAMA,gDAOC;AAMD,gEASC;AA3BD,6CAAmD;AAEnD;;GAEG;AACH,SAAgB,kBAAkB,CAAC,YAA+B;IAChE,IAAI,YAAY,CAAC,OAAO,KAAK,oBAAS,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CACb,uDAAuD,YAAY,CAAC,OAAO,6BAA6B,oBAAS,IAAI;YACnH,mHAAmH,CACtH,CAAA;IACH,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAgB,0BAA0B,CACxC,YAA+B;IAE/B,IAAI,YAAY,CAAC,OAAO,KAAK,oBAAS,EAAE,CAAC;QACvC,OAAO,CAAC,IAAI,CACV,oDAAoD,YAAY,CAAC,OAAO,sCAAsC,oBAAS,IAAI;YACzH,wFAAwF,CAC3F,CAAA;IACH,CAAC;AACH,CAAC","sourcesContent":["import type { NitroModulesProxy } from './NitroModulesProxy.js'\nimport { version as jsVersion } from './version.js'\n\n/**\n * Checks compatibility before reusing a proxy installed by another copy of Nitro.\n */\nexport function assertNitroVersion(nitroModules: NitroModulesProxy): void {\n  if (nitroModules.version !== jsVersion) {\n    throw new Error(\n      `Nitro was installed twice: once with native version ${nitroModules.version} and once with JS version ${jsVersion}. ` +\n        'This usually means different versions of Nitro exist in node_modules (e.g. in monorepos or double-linked setups).'\n    )\n  }\n}\n\n/**\n * Warns when the installed native runtime differs from this JavaScript package.\n * Host integrations should call this in development after installing Nitro.\n */\nexport function warnIfNitroVersionMismatch(\n  nitroModules: NitroModulesProxy\n): void {\n  if (nitroModules.version !== jsVersion) {\n    console.warn(\n      `The native Nitro Modules core runtime version is ${nitroModules.version}, but the JS code is using version ${jsVersion}. ` +\n        'This could lead to undefined behaviour! Make sure to keep your Nitro versions in sync.'\n    )\n  }\n}\n"]}

package/js/lib/commonjs/getHybridObjectConstructor.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHybridObjectConstructor = getHybridObjectConstructor;
+const NitroModules_js_1 = require("./NitroModules.js");
+const cache = new Map();
+/**
+ * Get a constructor function for the given `HybridObject` {@linkcode T}.
+ * @param name The name of the `HybridObject` under which it was registered at.
+ * @returns A constructor that creates instances of {@linkcode T}
+ * @example
+ * ```ts
+ * export const HybridImage = getHybridObjectConstructor<Image>('Image')
+ *
+ * const image1 = new HybridImage()
+ * const image2 = new HybridImage()
+ * image1 instanceof HybridImage // --> true
+ * ```
+ */
+function getHybridObjectConstructor(name) {
+    // Cache functions for performance.
+    if (cache.has(name)) {
+        return cache.get(name);
+    }
+    // A function that creates the HybridObject.
+    // This can be called with `new`, and internally sets the prototype.
+    const constructorFunc = function () {
+        const instance = (0, NitroModules_js_1.getNitroModules)().createHybridObject(name);
+        const prototype = Object.getPrototypeOf(instance);
+        if (constructorFunc.prototype !== prototype) {
+            constructorFunc.prototype = prototype;
+            constructorFunc.prototypeInitialized = true;
+        }
+        return instance;
+    };
+    // Configure lazy prototype. If `instanceof` is called before a `T`
+    // has been created, we just lazy-create a new `T` instance to set the proto.
+    constructorFunc.prototypeInitialized = false;
+    Object.defineProperty(constructorFunc, Symbol.hasInstance, {
+        value: (instance) => {
+            if (!constructorFunc.prototypeInitialized) {
+                // User didn't call `new T()` yet, so we don't
+                // know the prototype yet. Just create one temp object to find
+                // out the prototype.
+                const tempInstance = (0, NitroModules_js_1.getNitroModules)().createHybridObject(name);
+                constructorFunc.prototype = Object.getPrototypeOf(tempInstance);
+                constructorFunc.prototypeInitialized = true;
+            }
+            // Loop through the prototype chain of the value
+            // we're testing for to see if it is a direct instance
+            // of `T`, or a derivative of it.
+            let proto = Object.getPrototypeOf(instance);
+            while (proto != null) {
+                if (proto === constructorFunc.prototype) {
+                    return true;
+                }
+                proto = Object.getPrototypeOf(proto);
+            }
+            // No prototype overlap.
+            return false;
+        },
+    });
+    cache.set(name, constructorFunc);
+    return constructorFunc;
+}
+//# sourceMappingURL=getHybridObjectConstructor.js.map

package/js/lib/commonjs/getHybridObjectConstructor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getHybridObjectConstructor.js","sourceRoot":"","sources":["../../src/getHybridObjectConstructor.ts"],"names":[],"mappings":";;AAkBA,gEAkDC;AAnED,uDAAmD;AAEnD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAoB,CAAA;AAEzC;;;;;;;;;;;;GAYG;AACH,SAAgB,0BAA0B,CACxC,IAAY;IAEZ,mCAAmC;IACnC,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QACpB,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,CAAkB,CAAA;IACzC,CAAC;IAED,4CAA4C;IAC5C,oEAAoE;IACpE,MAAM,eAAe,GAAG;QACtB,MAAM,QAAQ,GAAG,IAAA,iCAAe,GAAE,CAAC,kBAAkB,CAAI,IAAI,CAAC,CAAA;QAC9D,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAA;QACjD,IAAI,eAAe,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5C,eAAe,CAAC,SAAS,GAAG,SAAS,CAAA;YACrC,eAAe,CAAC,oBAAoB,GAAG,IAAI,CAAA;QAC7C,CAAC;QACD,OAAO,QAAQ,CAAA;IACjB,CAAkE,CAAA;IAElE,mEAAmE;IACnE,6EAA6E;IAC7E,eAAe,CAAC,oBAAoB,GAAG,KAAK,CAAA;IAC5C,MAAM,CAAC,cAAc,CAAC,eAAe,EAAE,MAAM,CAAC,WAAW,EAAE;QACzD,KAAK,EAAE,CAAC,QAAiB,EAAE,EAAE;YAC3B,IAAI,CAAC,eAAe,CAAC,oBAAoB,EAAE,CAAC;gBAC1C,8CAA8C;gBAC9C,8DAA8D;gBAC9D,qBAAqB;gBACrB,MAAM,YAAY,GAAG,IAAA,iCAAe,GAAE,CAAC,kBAAkB,CAAI,IAAI,CAAC,CAAA;gBAClE,eAAe,CAAC,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,YAAY,CAAC,CAAA;gBAC/D,eAAe,CAAC,oBAAoB,GAAG,IAAI,CAAA;YAC7C,CAAC;YACD,gDAAgD;YAChD,sDAAsD;YACtD,iCAAiC;YACjC,IAAI,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAA;YAC3C,OAAO,KAAK,IAAI,IAAI,EAAE,CAAC;gBACrB,IAAI,KAAK,KAAK,eAAe,CAAC,SAAS,EAAE,CAAC;oBACxC,OAAO,IAAI,CAAA;gBACb,CAAC;gBACD,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAA;YACtC,CAAC;YACD,wBAAwB;YACxB,OAAO,KAAK,CAAA;QACd,CAAC;KACF,CAAC,CAAA;IAEF,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,eAAe,CAAC,CAAA;IAChC,OAAO,eAAe,CAAA;AACxB,CAAC","sourcesContent":["import type { HybridObject } from './HybridObject.js'\nimport { getNitroModules } from './NitroModules.js'\n\nconst cache = new Map<string, Function>()\n\n/**\n * Get a constructor function for the given `HybridObject` {@linkcode T}.\n * @param name The name of the `HybridObject` under which it was registered at.\n * @returns A constructor that creates instances of {@linkcode T}\n * @example\n * ```ts\n * export const HybridImage = getHybridObjectConstructor<Image>('Image')\n *\n * const image1 = new HybridImage()\n * const image2 = new HybridImage()\n * image1 instanceof HybridImage // --> true\n * ```\n */\nexport function getHybridObjectConstructor<T extends HybridObject<{}>>(\n  name: string\n): { new (): T } {\n  // Cache functions for performance.\n  if (cache.has(name)) {\n    return cache.get(name) as { new (): T }\n  }\n\n  // A function that creates the HybridObject.\n  // This can be called with `new`, and internally sets the prototype.\n  const constructorFunc = function () {\n    const instance = getNitroModules().createHybridObject<T>(name)\n    const prototype = Object.getPrototypeOf(instance)\n    if (constructorFunc.prototype !== prototype) {\n      constructorFunc.prototype = prototype\n      constructorFunc.prototypeInitialized = true\n    }\n    return instance\n  } as unknown as { new (): T } & { prototypeInitialized?: boolean }\n\n  // Configure lazy prototype. If `instanceof` is called before a `T`\n  // has been created, we just lazy-create a new `T` instance to set the proto.\n  constructorFunc.prototypeInitialized = false\n  Object.defineProperty(constructorFunc, Symbol.hasInstance, {\n    value: (instance: unknown) => {\n      if (!constructorFunc.prototypeInitialized) {\n        // User didn't call `new T()` yet, so we don't\n        // know the prototype yet. Just create one temp object to find\n        // out the prototype.\n        const tempInstance = getNitroModules().createHybridObject<T>(name)\n        constructorFunc.prototype = Object.getPrototypeOf(tempInstance)\n        constructorFunc.prototypeInitialized = true\n      }\n      // Loop through the prototype chain of the value\n      // we're testing for to see if it is a direct instance\n      // of `T`, or a derivative of it.\n      let proto = Object.getPrototypeOf(instance)\n      while (proto != null) {\n        if (proto === constructorFunc.prototype) {\n          return true\n        }\n        proto = Object.getPrototypeOf(proto)\n      }\n      // No prototype overlap.\n      return false\n    },\n  })\n\n  cache.set(name, constructorFunc)\n  return constructorFunc\n}\n"]}

package/js/lib/commonjs/globals.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=globals.js.map

package/js/lib/commonjs/globals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"globals.js","sourceRoot":"","sources":["../../src/globals.ts"],"names":[],"mappings":"","sourcesContent":["declare global {\n  /**\n   * The native `JSICache` for Nitro.\n   * This is created on the fly natively when needed.\n   * @readonly\n   */\n  var __nitroJsiCache: {} | undefined\n  /**\n   * The native `Dispatcher` for Nitro.\n   *\n   * A `Dispatcher` is only available in a `jsi::Runtime` when\n   * it was installed using `Dispatcher::installRuntimeGlobalDispatcher(...)`.\n   *\n   * If you use a `jsi::Runtime` that does not have a `Dispatcher` ({@linkcode __nitroDispatcher} `==` `null`),\n   * any asynchronous operations (`Callbacks` or `Promises`) will throw an error.\n   * You would need to either:\n   * - A) Install a `Dispatcher` that can safely thread-hop (\"dispatch\") to this `jsi::Runtime` on the native side\n   * - B) Only use synchronous methods and no callbacks on this `jsi::Runtime`.\n   * @readonly\n   */\n  var __nitroDispatcher: {} | undefined\n  /**\n   * The global proxy object that can create other autolinked HybridObjects.\n   */\n  var NitroModulesProxy: {} | undefined\n}\n\n// ensures this file is treated as a module\nexport {}\n"]}

package/js/lib/commonjs/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./globals.js");
+__exportStar(require("./AnyHybridObject.js"), exports);
+__exportStar(require("./AnyMap.js"), exports);
+__exportStar(require("./BoxedHybridObject.js"), exports);
+__exportStar(require("./CustomType.js"), exports);
+__exportStar(require("./getHybridObjectConstructor.js"), exports);
+__exportStar(require("./HybridObject.js"), exports);
+__exportStar(require("./Int64.js"), exports);
+__exportStar(require("./NitroModules.js"), exports);
+__exportStar(require("./NitroModulesProxy.js"), exports);
+__exportStar(require("./Sync.js"), exports);
+__exportStar(require("./checkNitroVersion.js"), exports);
+//# sourceMappingURL=index.js.map

package/js/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wBAAqB;AAErB,uDAAoC;AACpC,8CAA2B;AAC3B,yDAAsC;AACtC,kDAA+B;AAC/B,kEAA+C;AAC/C,oDAAiC;AACjC,6CAA0B;AAC1B,oDAAiC;AACjC,yDAAsC;AACtC,4CAAyB;AACzB,yDAAsC","sourcesContent":["import './globals.js'\n\nexport * from './AnyHybridObject.js'\nexport * from './AnyMap.js'\nexport * from './BoxedHybridObject.js'\nexport * from './CustomType.js'\nexport * from './getHybridObjectConstructor.js'\nexport * from './HybridObject.js'\nexport * from './Int64.js'\nexport * from './NitroModules.js'\nexport * from './NitroModulesProxy.js'\nexport * from './Sync.js'\nexport * from './checkNitroVersion.js'\n"]}

package/js/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/js/lib/commonjs/version.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+// Updated by scripts/set-version.mjs with the native NITRO_VERSION.
+exports.version = '0.37.2-nightly.32.gcd7b91624dde';
+//# sourceMappingURL=version.js.map

package/js/lib/commonjs/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":";;;AAAA,oEAAoE;AACvD,QAAA,OAAO,GAAG,iCAAiC,CAAA","sourcesContent":["// Updated by scripts/set-version.mjs with the native NITRO_VERSION.\nexport const version = '0.37.2-nightly.32.gcd7b91624dde'\n"]}

package/js/lib/module/AnyHybridObject.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AnyHybridObject.js.map

package/js/lib/module/AnyHybridObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnyHybridObject.js","sourceRoot":"","sources":["../../src/AnyHybridObject.ts"],"names":[],"mappings":"","sourcesContent":["import type { HybridObject } from './HybridObject.js'\n\n/**\n * Represents a value of the base `HybridObject` type all other\n * HybridObjects inherit from.\n * This is not type-checked to an actual `HybridObject` (boxed).\n */\nexport interface AnyHybridObject extends HybridObject<{}> {\n  __anyHybridObjectTag?: never\n}\n"]}

package/js/lib/module/AnyMap.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AnyMap.js.map

package/js/lib/module/AnyMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnyMap.js","sourceRoot":"","sources":["../../src/AnyMap.ts"],"names":[],"mappings":"","sourcesContent":["import type { Int64 } from './Int64.js'\n\n/**\n * Represents a single value inside an untyped map.\n */\nexport type ValueType =\n  | string\n  | number\n  | boolean\n  | Int64\n  | null\n  | ValueType[]\n  | { [k: string]: ValueType }\n\n/**\n * Represents an untyped map, similar to a JSON structure.\n * Supported types:\n * - Primitives (`string`, `number`, `boolean`, `Int64`, `null`)\n * - Arrays of primitives (`ValueType[]`)\n * - Objects of primitives (`Record<string, ValueType>`)\n * - Arrays of arrays or objects\n * - Objects of arrays or objects\n *\n * @note It is recommended to always use typed `interface`s instead of `AnyMap` for\n * both type safety, as well as better performance.\n */\nexport type AnyMap = Record<string, ValueType>\n"]}

package/js/lib/module/BoxedHybridObject.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BoxedHybridObject.js.map

package/js/lib/module/BoxedHybridObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoxedHybridObject.js","sourceRoot":"","sources":["../../src/BoxedHybridObject.ts"],"names":[],"mappings":"","sourcesContent":["import type { HybridObject } from './HybridObject.js'\n\n/**\n * Represents a boxed {@linkcode HybridObject} that can later be unboxed again.\n * This is implemented as a `jsi::HostObject`.\n */\nexport interface BoxedHybridObject<T extends HybridObject<{}>> {\n  /**\n   * Unboxes the {@linkcode HybridObject}.\n   * This can be called from a different Runtime than the one it was boxed in.\n   */\n  unbox(): T\n}\n"]}

package/js/lib/module/CustomType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CustomType.js.map

package/js/lib/module/CustomType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomType.js","sourceRoot":"","sources":["../../src/CustomType.ts"],"names":[],"mappings":"","sourcesContent":["export interface CustomTypeConfig {\n  /**\n   * Represents the name of the C++ header that will be included\n   * to support your type.\n   *\n   * This C++ header should be written by you, and findable within\n   * the user-search-paths so it can be included.\n   */\n  include: string\n  /**\n   * A flag that enables const-reference passing for heavy types\n   * to prevent unnecessary copies.\n   * When `true`, the type will be passed to clients as a `const T&` instead of just `T`.\n   * @default false\n   */\n  canBePassedByReference?: boolean\n}\n\n/**\n * Represents a custom, manually written native type.\n * - {@linkcode TypeName}: Represents the name of the C++ type (class, struct, alias).\n * - {@linkcode Config}: Configures how the C++ type is included, used, and typed.\n *\n * **You** then need to create a header file that is importable with the filename specified in {@linkcode Config.include}.\n * @example\n * ```ts\n * type MyOwnString = CustomType<string, 'MyOwnString', { include: 'MyOwnString.hpp' }>\n * interface MyHybrid extends HybridObject<{ … }> {\n *   getValue(): MyOwnString\n * }\n * ```\n * The C++ header will always be included by Nitro as a user-search-path header, that is;\n * ```cpp\n * #include \"MyOwnString.hpp\"\n * ```\n * The C++ header (`MyOwnString.hpp`) then needs to define the type `MyOwnString`\n * within the namespace of your Nitro Module (`namespace margelo::nitro::...`),\n * and an overload for `JSIConverter<MyOwnString>` within the Nitro core namespace\n * (`namespace margelo::nitro`):\n * ```cpp\n * namespace margelo::nitro::test {\n *   using MyOwnString = std::string;\n * }\n * namespace margelo::nitro {\n *   template<>\n *   struct JSIConverter<test::MyOwnString> final {\n *     static test::MyOwnString fromJSI(jsi::Runtime&, const jsi::Value&);\n *     static jsi::Value toJSI(jsi::Runtime&, test::MyOwnString);\n *     static bool canConvert(jsi::Runtime&, const jsi::Value& value);\n *   }\n * }\n * ```\n */\nexport type CustomType<\n  T,\n  TypeName extends string,\n  Config extends CustomTypeConfig,\n> = T & {\n  readonly __customTypeName?: TypeName\n  readonly __customTypeConfig?: Config\n}\n"]}

package/js/lib/module/HybridObject.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=HybridObject.js.map

package/js/lib/module/HybridObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HybridObject.js","sourceRoot":"","sources":["../../src/HybridObject.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Describes the languages this component will be implemented in.\n *\n * By default, everything has a C++ base, and can optionally be bridged down\n * to platform-specific languages like Swift or Kotlin\n */\nexport interface PlatformSpec {\n  ios?: 'c++' | 'swift'\n  android?: 'c++' | 'kotlin'\n}\n\n/**\n * Represents a Nitro `HybridObject` which is implemented in a native language like\n * C++, Swift or Kotlin.\n * Every Nitro `HybridObject` has a C++ base, and can optionally be bridged down to Swift or Kotlin.\n *\n * `HybridObject`s use the Nitro Tunnel for efficient, low-overhead JS <-> Native communication.\n *\n * All `HybridObject`s are implemented using `NativeState`, and inherit their properties\n * and methods from their prototype, so the actual JS object is empty.\n *\n * @type Platforms: The type of platforms this HybridObject will be implemented in.\n * @example\n * ```ts\n * interface Photo extends HybridObject<{ ios: 'swift', android: 'kotlin' }> {\n *   readonly width: number\n *   readonly height: number\n *   toArrayBuffer(): ArrayBuffer\n *   saveToFile(path: string): Promise<void>\n * }\n * ```\n */\nexport interface HybridObject<Platforms extends PlatformSpec> {\n  /**\n   * Holds a type-name describing the native `HybridObject` instance.\n   *\n   * This is the only property actually present on the actual JavaScript object,\n   * because all other properties and methods are inherited from a shared Prototype.\n   *\n   * Nitro prototypes also have a `__type`.\n   *\n   * - For actual HybridObject instances, this is `HybridObject<...>`\n   * - For prototypes this is `Prototype<...>`.\n   *\n   * @internal\n   * @private\n   * @note This value is available in debug only.\n   */\n  readonly __type?: string\n  /**\n   * The `HybridObject`'s name.\n   */\n  readonly name: string\n  /**\n   * Returns a string representation of the given `HybridObject`.\n   *\n   * Unless overridden by the `HybridObject`, this will return the name of the object.\n   *\n   * @example\n   * ```ts\n   * const hybridA = SomeModule.getExistingHybridInstance()\n   * console.log(hybridA.toString()) // [HybridObject HybridA]\n   * ```\n   */\n  toString(): string\n  /**\n   * Returns whether this `HybridObject` is the same object as {@linkcode other}.\n   *\n   * While two `HybridObject`s might not be equal when compared with `==`, they might still\n   * hold the same underlying `HybridObject`, in which case {@linkcode equals | equals(other)}\n   * will return `true`.\n   *\n   * @example\n   * ```ts\n   * const hybridA = SomeModule.getExistingHybridInstance()\n   * const hybridB = SomeModule.getExistingHybridInstance()\n   * console.log(hybridA.equals(hybridB)) // true\n   * ```\n   */\n  equals(other: HybridObject<Platforms>): boolean\n  /**\n   * Disposes any resources this {@linkcode HybridObject} might hold natively,\n   * and releases this {@linkcode HybridObject}'s `NativeState`.\n   *\n   * After calling {@linkcode dispose()}, this object can no longer be used.\n   *\n   * Eagerly disposing a {@linkcode HybridObject} could be beneficial for a queue-/handler-architecture\n   * where a bunch of Hybrid Objects are allocated, and later deallocated once a callback (e.g. a render function)\n   * completes.\n   *\n   * @note It is **NOT** required to call {@linkcode dispose()} manually, as the JavaScript\n   * Garbage Collector automatically disposes and releases any resources when needed.\n   * It is purely optional to eagerly-, and manually-, call {@linkcode dispose()} here - **use with caution!**\n   */\n  dispose(): void\n}\n"]}

package/js/lib/module/Int64.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Int64.js.map

package/js/lib/module/Int64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Int64.js","sourceRoot":"","sources":["../../src/Int64.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Represents an unsigned 64-bit integer (or \"uint64\").\n */\nexport type UInt64 = bigint & { __unsignedTag?: never }\n\n/**\n * Represents a signed 64-bit integer (or \"int64\").\n */\nexport type Int64 = bigint & { __signedTag?: never }\n"]}

package/js/lib/module/NitroModules.js

@@ -0,0 +1,37 @@
+import './globals.js';
+/**
+ * The installed native Nitro entry point.
+ *
+ * A host integration must call {@linkcode getNitroModules} after installing
+ * Nitro into the JavaScript runtime. The binding then refers to that same
+ * native object, including its NativeState and prototype.
+ */
+export let NitroModules;
+/**
+ * Returns the native proxy, if this JavaScript runtime has installed Nitro.
+ * This does not install Nitro or initialize the {@linkcode NitroModules} binding.
+ */
+export function getInstalledNitro() {
+    return globalThis.NitroModulesProxy;
+}
+/**
+ * Returns the installed native proxy and initializes {@linkcode NitroModules}.
+ * The host integration is responsible for installing Nitro first.
+ */
+export function getNitroModules() {
+    const nitroModules = getInstalledNitro();
+    if (nitroModules == null) {
+        throw new Error('Nitro is not installed in this JavaScript runtime. Initialize the host integration before using NitroModules.');
+    }
+    NitroModules = nitroModules;
+    return nitroModules;
+}
+/**
+ * Returns whether the runtime still has Nitro's JSI cache and dispatcher.
+ */
+export function isRuntimeAlive() {
+    const cache = globalThis.__nitroJsiCache;
+    const dispatcher = globalThis.__nitroDispatcher;
+    return cache != null && dispatcher != null;
+}
+//# sourceMappingURL=NitroModules.js.map

package/js/lib/module/NitroModules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NitroModules.js","sourceRoot":"","sources":["../../src/NitroModules.ts"],"names":[],"mappings":"AACA,OAAO,cAAc,CAAA;AAErB;;;;;;GAMG;AACH,MAAM,CAAC,IAAI,YAA+B,CAAA;AAE1C;;;GAGG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,UAAU,CAAC,iBAAkD,CAAA;AACtE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe;IAC7B,MAAM,YAAY,GAAG,iBAAiB,EAAE,CAAA;IACxC,IAAI,YAAY,IAAI,IAAI,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CACb,+GAA+G,CAChH,CAAA;IACH,CAAC;IACD,YAAY,GAAG,YAAY,CAAA;IAC3B,OAAO,YAAY,CAAA;AACrB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc;IAC5B,MAAM,KAAK,GAAG,UAAU,CAAC,eAAe,CAAA;IACxC,MAAM,UAAU,GAAG,UAAU,CAAC,iBAAiB,CAAA;IAC/C,OAAO,KAAK,IAAI,IAAI,IAAI,UAAU,IAAI,IAAI,CAAA;AAC5C,CAAC","sourcesContent":["import type { NitroModulesProxy } from './NitroModulesProxy.js'\nimport './globals.js'\n\n/**\n * The installed native Nitro entry point.\n *\n * A host integration must call {@linkcode getNitroModules} after installing\n * Nitro into the JavaScript runtime. The binding then refers to that same\n * native object, including its NativeState and prototype.\n */\nexport let NitroModules: NitroModulesProxy\n\n/**\n * Returns the native proxy, if this JavaScript runtime has installed Nitro.\n * This does not install Nitro or initialize the {@linkcode NitroModules} binding.\n */\nexport function getInstalledNitro(): NitroModulesProxy | undefined {\n  return globalThis.NitroModulesProxy as NitroModulesProxy | undefined\n}\n\n/**\n * Returns the installed native proxy and initializes {@linkcode NitroModules}.\n * The host integration is responsible for installing Nitro first.\n */\nexport function getNitroModules(): NitroModulesProxy {\n  const nitroModules = getInstalledNitro()\n  if (nitroModules == null) {\n    throw new Error(\n      'Nitro is not installed in this JavaScript runtime. Initialize the host integration before using NitroModules.'\n    )\n  }\n  NitroModules = nitroModules\n  return nitroModules\n}\n\n/**\n * Returns whether the runtime still has Nitro's JSI cache and dispatcher.\n */\nexport function isRuntimeAlive(): boolean {\n  const cache = globalThis.__nitroJsiCache\n  const dispatcher = globalThis.__nitroDispatcher\n  return cache != null && dispatcher != null\n}\n"]}

package/js/lib/module/NitroModulesProxy.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=NitroModulesProxy.js.map

package/js/lib/module/NitroModulesProxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NitroModulesProxy.js","sourceRoot":"","sources":["../../src/NitroModulesProxy.ts"],"names":[],"mappings":"","sourcesContent":["import type { HybridObject } from './HybridObject.js'\nimport type { BoxedHybridObject } from './BoxedHybridObject.js'\n\n/**\n * The native entry point for Nitro Modules in a JavaScript runtime.\n *\n * This is a `HybridObject` on the native side as well, and is expected to be\n * installed into the runtime's `global` by the host integration.\n */\nexport interface NitroModulesProxy extends HybridObject<{\n  ios: 'c++'\n  android: 'c++'\n}> {\n  /**\n   * Create a new instance of the `HybridObject` {@linkcode T}.\n   *\n   * {@linkcode T} has to be registered beforehand under the name {@linkcode name}\n   * in the native Nitro Modules `HybridObjectRegistry`.\n   *\n   * @param name The name of the `HybridObject` under which it was registered at.\n   * @returns An instance of {@linkcode T}\n   * @throws an Error if {@linkcode T} has not been registered under the name {@linkcode name}.\n   */\n  createHybridObject<T extends HybridObject<{}>>(name: string): T\n  /**\n   * Returns whether a HybridObject under the given {@linkcode name} is registered, or not.\n   */\n  hasHybridObject(name: string): boolean\n  /**\n   * Returns whether the given {@linkcode object} is a {@linkcode HybridObject}, or not.\n   */\n  isHybridObject(object: object): object is HybridObject<{}>\n  /**\n   * Get a list of all registered Hybrid Objects.\n   */\n  getAllHybridObjectNames(): string[]\n\n  /**\n   * Gets the current build type configuration as defined in the `NITRO_DEBUG`\n   * preprocessor flag.\n   */\n  buildType: 'debug' | 'release'\n  /**\n   * Gets the native Nitro Modules core runtime version that this app is built with.\n   * This should be kept in sync with the JS version (package.json), otherwise it could\n   * introduce undefined behaviour.\n   */\n  version: string\n\n  /**\n   * Boxes the given {@linkcode hybridObject} into a {@linkcode BoxedHybridObject<T>}, which can\n   * later be unboxed in a separate Runtime.\n   *\n   * While Nitro is runtime-agnostic and all `HybridObject`s can be used from a any Runtime,\n   * some threading/worklet libraries (like [react-native-worklets-core](https://github.com/margelo/react-native-worklets-core))\n   * do not yet support copying over `HybridObject`s as they use newer JSI APIs like `jsi::NativeState`.\n   *\n   * While those APIs are not yet available, you can still use every Nitro Hybrid Object in a separate\n   * Runtime/Worklet context by just boxing it yourself:\n   *\n   * @example\n   * ```ts\n   * const something = NitroModules.createHybridObject<Something>('Something')\n   * const boxed = NitroModules.box(something)\n   * const context = Worklets.createContext('DummyContext')\n   * context.runAsync(() => {\n   *   'worklet'\n   *   const unboxed = boxed.unbox()\n   *   console.log(unboxed.name) // --> \"Something\"\n   * })\n   * ```\n   */\n  box<T extends HybridObject<{}>>(obj: T): BoxedHybridObject<T>\n\n  /**\n   * Returns whether the given {@linkcode object} has NativeState or not.\n   */\n  hasNativeState(object: unknown): boolean\n\n  /**\n   * Re-calculates `memorySize` of the given {@linkcode HybridObject} and notifies\n   * the JS VM about the newly updated memory footprint.\n   *\n   * This is achieved by just doing a round-trip from JS -> native -> JS.\n   */\n  updateMemorySize<T extends HybridObject<{}>>(obj: T): T\n\n  /**\n   * Allocate a new native {@linkcode ArrayBuffer} with the\n   * given {@linkcode size}.\n   *\n   * As opposed to creating an {@linkcode ArrayBuffer} from JS,\n   * this method returns a buffer that can be directly read from\n   * and written to in Nitro Modules without copying, as native\n   * owns it - not JS.\n   */\n  createNativeArrayBuffer(size: number): ArrayBuffer\n\n  /**\n   * Gets a total number of currently allocated {@linkcode HybridObject}s.\n   * @internal\n   */\n  debug_getTotalAllocatedHybridObjects(): number\n}\n"]}

package/js/lib/module/Sync.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Sync.js.map

package/js/lib/module/Sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sync.js","sourceRoot":"","sources":["../../src/Sync.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Marks the given function as _synchronous_, allowing it to be called synchronously on the same\n * Thread.\n *\n * This allows for fast native -> JS calls and avoids any asynchronous dispatching, but requires careful\n * threading considerations.\n */\nexport type Sync<T> = T extends Function ? T & { __syncTag?: never } : never\n"]}

package/js/lib/module/checkNitroVersion.js

@@ -0,0 +1,21 @@
+import { version as jsVersion } from './version.js';
+/**
+ * Checks compatibility before reusing a proxy installed by another copy of Nitro.
+ */
+export function assertNitroVersion(nitroModules) {
+    if (nitroModules.version !== jsVersion) {
+        throw new Error(`Nitro was installed twice: once with native version ${nitroModules.version} and once with JS version ${jsVersion}. ` +
+            'This usually means different versions of Nitro exist in node_modules (e.g. in monorepos or double-linked setups).');
+    }
+}
+/**
+ * Warns when the installed native runtime differs from this JavaScript package.
+ * Host integrations should call this in development after installing Nitro.
+ */
+export function warnIfNitroVersionMismatch(nitroModules) {
+    if (nitroModules.version !== jsVersion) {
+        console.warn(`The native Nitro Modules core runtime version is ${nitroModules.version}, but the JS code is using version ${jsVersion}. ` +
+            'This could lead to undefined behaviour! Make sure to keep your Nitro versions in sync.');
+    }
+}
+//# sourceMappingURL=checkNitroVersion.js.map

package/js/lib/module/checkNitroVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkNitroVersion.js","sourceRoot":"","sources":["../../src/checkNitroVersion.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,cAAc,CAAA;AAEnD;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,YAA+B;IAChE,IAAI,YAAY,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CACb,uDAAuD,YAAY,CAAC,OAAO,6BAA6B,SAAS,IAAI;YACnH,mHAAmH,CACtH,CAAA;IACH,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,0BAA0B,CACxC,YAA+B;IAE/B,IAAI,YAAY,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QACvC,OAAO,CAAC,IAAI,CACV,oDAAoD,YAAY,CAAC,OAAO,sCAAsC,SAAS,IAAI;YACzH,wFAAwF,CAC3F,CAAA;IACH,CAAC;AACH,CAAC","sourcesContent":["import type { NitroModulesProxy } from './NitroModulesProxy.js'\nimport { version as jsVersion } from './version.js'\n\n/**\n * Checks compatibility before reusing a proxy installed by another copy of Nitro.\n */\nexport function assertNitroVersion(nitroModules: NitroModulesProxy): void {\n  if (nitroModules.version !== jsVersion) {\n    throw new Error(\n      `Nitro was installed twice: once with native version ${nitroModules.version} and once with JS version ${jsVersion}. ` +\n        'This usually means different versions of Nitro exist in node_modules (e.g. in monorepos or double-linked setups).'\n    )\n  }\n}\n\n/**\n * Warns when the installed native runtime differs from this JavaScript package.\n * Host integrations should call this in development after installing Nitro.\n */\nexport function warnIfNitroVersionMismatch(\n  nitroModules: NitroModulesProxy\n): void {\n  if (nitroModules.version !== jsVersion) {\n    console.warn(\n      `The native Nitro Modules core runtime version is ${nitroModules.version}, but the JS code is using version ${jsVersion}. ` +\n        'This could lead to undefined behaviour! Make sure to keep your Nitro versions in sync.'\n    )\n  }\n}\n"]}

package/js/lib/module/getHybridObjectConstructor.js

@@ -0,0 +1,62 @@
+import { getNitroModules } from './NitroModules.js';
+const cache = new Map();
+/**
+ * Get a constructor function for the given `HybridObject` {@linkcode T}.
+ * @param name The name of the `HybridObject` under which it was registered at.
+ * @returns A constructor that creates instances of {@linkcode T}
+ * @example
+ * ```ts
+ * export const HybridImage = getHybridObjectConstructor<Image>('Image')
+ *
+ * const image1 = new HybridImage()
+ * const image2 = new HybridImage()
+ * image1 instanceof HybridImage // --> true
+ * ```
+ */
+export function getHybridObjectConstructor(name) {
+    // Cache functions for performance.
+    if (cache.has(name)) {
+        return cache.get(name);
+    }
+    // A function that creates the HybridObject.
+    // This can be called with `new`, and internally sets the prototype.
+    const constructorFunc = function () {
+        const instance = getNitroModules().createHybridObject(name);
+        const prototype = Object.getPrototypeOf(instance);
+        if (constructorFunc.prototype !== prototype) {
+            constructorFunc.prototype = prototype;
+            constructorFunc.prototypeInitialized = true;
+        }
+        return instance;
+    };
+    // Configure lazy prototype. If `instanceof` is called before a `T`
+    // has been created, we just lazy-create a new `T` instance to set the proto.
+    constructorFunc.prototypeInitialized = false;
+    Object.defineProperty(constructorFunc, Symbol.hasInstance, {
+        value: (instance) => {
+            if (!constructorFunc.prototypeInitialized) {
+                // User didn't call `new T()` yet, so we don't
+                // know the prototype yet. Just create one temp object to find
+                // out the prototype.
+                const tempInstance = getNitroModules().createHybridObject(name);
+                constructorFunc.prototype = Object.getPrototypeOf(tempInstance);
+                constructorFunc.prototypeInitialized = true;
+            }
+            // Loop through the prototype chain of the value
+            // we're testing for to see if it is a direct instance
+            // of `T`, or a derivative of it.
+            let proto = Object.getPrototypeOf(instance);
+            while (proto != null) {
+                if (proto === constructorFunc.prototype) {
+                    return true;
+                }
+                proto = Object.getPrototypeOf(proto);
+            }
+            // No prototype overlap.
+            return false;
+        },
+    });
+    cache.set(name, constructorFunc);
+    return constructorFunc;
+}
+//# sourceMappingURL=getHybridObjectConstructor.js.map