@lucent-lang/lucent 0.0.4

package/runtime/cpp/third_party/quickjs/libunicode.h

@@ -0,0 +1,196 @@
+/*
+ * Unicode utilities
+ *
+ * Copyright (c) 2017-2018 Fabrice Bellard
+ *
+ * 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.
+ */
+#ifndef LIBUNICODE_H
+#define LIBUNICODE_H
+
+#include <stdint.h>
+
+/* unicode standard version */
+#define LIBUNICODE_UNICODE_VERSION_MAJOR 17
+#define LIBUNICODE_UNICODE_VERSION_MINOR 0
+#define LIBUNICODE_UNICODE_VERSION_PATCH 0
+
+/* define it to include all the unicode tables (40KB larger) */
+#define CONFIG_ALL_UNICODE
+
+#define LRE_CC_RES_LEN_MAX 3
+
+/* char ranges */
+
+typedef struct {
+    int len; /* in points, always even */
+    int size;
+    uint32_t *points; /* points sorted by increasing value */
+    void *mem_opaque;
+    void *(*realloc_func)(void *opaque, void *ptr, size_t size);
+} CharRange;
+
+typedef enum {
+    CR_OP_UNION,
+    CR_OP_INTER,
+    CR_OP_XOR,
+    CR_OP_SUB,
+} CharRangeOpEnum;
+
+void cr_init(CharRange *cr, void *mem_opaque, void *(*realloc_func)(void *opaque, void *ptr, size_t size));
+void cr_free(CharRange *cr);
+int cr_realloc(CharRange *cr, int size);
+int cr_copy(CharRange *cr, const CharRange *cr1);
+
+static inline int cr_add_point(CharRange *cr, uint32_t v)
+{
+    if (cr->len >= cr->size) {
+        if (cr_realloc(cr, cr->len + 1))
+            return -1;
+    }
+    cr->points[cr->len++] = v;
+    return 0;
+}
+
+static inline int cr_add_interval(CharRange *cr, uint32_t c1, uint32_t c2)
+{
+    if ((cr->len + 2) > cr->size) {
+        if (cr_realloc(cr, cr->len + 2))
+            return -1;
+    }
+    cr->points[cr->len++] = c1;
+    cr->points[cr->len++] = c2;
+    return 0;
+}
+
+int cr_op(CharRange *cr, const uint32_t *a_pt, int a_len,
+          const uint32_t *b_pt, int b_len, int op);
+int cr_op1(CharRange *cr, const uint32_t *b_pt, int b_len, int op);
+
+static inline int cr_union_interval(CharRange *cr, uint32_t c1, uint32_t c2)
+{
+    uint32_t b_pt[2];
+    b_pt[0] = c1;
+    b_pt[1] = c2 + 1;
+    return cr_op1(cr, b_pt, 2, CR_OP_UNION);
+}
+
+int cr_invert(CharRange *cr);
+
+int cr_regexp_canonicalize(CharRange *cr, int is_unicode);
+
+typedef enum {
+    UNICODE_NFC,
+    UNICODE_NFD,
+    UNICODE_NFKC,
+    UNICODE_NFKD,
+} UnicodeNormalizationEnum;
+
+int unicode_normalize(uint32_t **pdst, const uint32_t *src, int src_len,
+                      UnicodeNormalizationEnum n_type,
+                      void *opaque, void *(*realloc_func)(void *opaque, void *ptr, size_t size));
+
+/* Unicode character range functions */
+
+int unicode_script(CharRange *cr, const char *script_name, int is_ext);
+int unicode_general_category(CharRange *cr, const char *gc_name);
+int unicode_prop(CharRange *cr, const char *prop_name);
+
+typedef void UnicodeSequencePropCB(void *opaque, const uint32_t *buf, int len);
+int unicode_sequence_prop(const char *prop_name, UnicodeSequencePropCB *cb, void *opaque,
+                          CharRange *cr);
+
+int lre_case_conv(uint32_t *res, uint32_t c, int conv_type);
+int lre_canonicalize(uint32_t c, int is_unicode);
+
+/* Code point type categories */
+enum {
+    UNICODE_C_SPACE  = (1 << 0),
+    UNICODE_C_DIGIT  = (1 << 1),
+    UNICODE_C_UPPER  = (1 << 2),
+    UNICODE_C_LOWER  = (1 << 3),
+    UNICODE_C_UNDER  = (1 << 4),
+    UNICODE_C_DOLLAR = (1 << 5),
+    UNICODE_C_XDIGIT = (1 << 6),
+};
+extern uint8_t const lre_ctype_bits[256];
+
+/* zero or non-zero return value */
+int lre_is_cased(uint32_t c);
+int lre_is_case_ignorable(uint32_t c);
+int lre_is_id_start(uint32_t c);
+int lre_is_id_continue(uint32_t c);
+
+static inline int lre_is_space_byte(uint8_t c) {
+    return lre_ctype_bits[c] & UNICODE_C_SPACE;
+}
+
+static inline int lre_is_id_start_byte(uint8_t c) {
+    return lre_ctype_bits[c] & (UNICODE_C_UPPER | UNICODE_C_LOWER |
+                                UNICODE_C_UNDER | UNICODE_C_DOLLAR);
+}
+
+static inline int lre_is_id_continue_byte(uint8_t c) {
+    return lre_ctype_bits[c] & (UNICODE_C_UPPER | UNICODE_C_LOWER |
+                                UNICODE_C_UNDER | UNICODE_C_DOLLAR |
+                                UNICODE_C_DIGIT);
+}
+
+static inline int lre_is_word_byte(uint8_t c) {
+    return lre_ctype_bits[c] & (UNICODE_C_UPPER | UNICODE_C_LOWER |
+                                UNICODE_C_UNDER | UNICODE_C_DIGIT);
+}
+
+int lre_is_space_non_ascii(uint32_t c);
+
+static inline int lre_is_space(uint32_t c) {
+    if (c < 256)
+        return lre_is_space_byte(c);
+    else
+        return lre_is_space_non_ascii(c);
+}
+
+static inline int lre_js_is_ident_first(uint32_t c) {
+    if (c < 128) {
+        return lre_is_id_start_byte(c);
+    } else {
+#ifdef CONFIG_ALL_UNICODE
+        return lre_is_id_start(c);
+#else
+        return !lre_is_space_non_ascii(c);
+#endif
+    }
+}
+
+static inline int lre_js_is_ident_next(uint32_t c) {
+    if (c < 128) {
+        return lre_is_id_continue_byte(c);
+    } else {
+        /* ZWNJ and ZWJ are accepted in identifiers */
+        if (c >= 0x200C && c <= 0x200D)
+            return TRUE;
+#ifdef CONFIG_ALL_UNICODE
+        return lre_is_id_continue(c);
+#else
+        return !lre_is_space_non_ascii(c);
+#endif
+    }
+}
+
+#endif /* LIBUNICODE_H */

package/runtime/js/index.d.ts

@@ -0,0 +1,7 @@
+/** Returns the exports object of a compiled Lucent module. */
+export declare function loadModule(
+  name: string,
+  registry: () => { get(name: string): unknown },
+): Record<string, unknown>;
+/** Wraps a native class factory in a constructor usable with `new`. */
+export declare function lucentClass<T>(factory: T): T;

package/runtime/js/index.js

@@ -0,0 +1,60 @@
+"use strict";
+// Loads Lucent modules from the native "Lucent" TurboModule. `lucent build`
+// copies it into the native package (js/_lucent/runtime.js), and the generated
+// proxies (what Metro bundles in place of each *.lucent.ts file) require it
+// from there and call loadModule().
+// This file must not require "react-native" itself: the proxy passes the
+// app's own TurboModuleRegistry in.
+
+let native;
+
+function getNative(registry) {
+  if (native) return native;
+  // Test hosts install modules directly.
+  if (typeof globalThis.__lucentModules === "object" && globalThis.__lucentModules) {
+    native = globalThis.__lucentModules;
+    return native;
+  }
+  native = registry().get("Lucent");
+  if (!native) {
+    throw new Error(
+      "Lucent: the native module is not linked. Run `lucent build`, then rebuild the app " +
+        "(iOS: `pod install` first).",
+    );
+  }
+  return native;
+}
+
+/**
+ * The exports of a compiled Lucent module.
+ * @param {string} name module name (the file name without .lucent.ts)
+ * @param {() => { get(name: string): any }} registry returns React Native's TurboModuleRegistry
+ */
+function loadModule(name, registry) {
+  const m = getNative(registry)[name];
+  if (!m) {
+    throw new Error(
+      `Lucent: module "${name}" is not in the native build. Run \`lucent build\` and rebuild the app.`,
+    );
+  }
+  return m;
+}
+
+/** Wraps a native class factory in a real constructor so `new` and `instanceof` work. */
+function lucentClass(factory) {
+  function LucentClass() {
+    if (!new.target) throw new TypeError("Class constructor cannot be invoked without 'new'");
+    return factory.apply(undefined, arguments);
+  }
+  LucentClass.prototype = factory.prototype;
+  Object.defineProperty(LucentClass.prototype, "constructor", {
+    value: LucentClass,
+    configurable: true,
+    writable: true,
+  });
+  Object.defineProperty(LucentClass, "name", { value: factory.name });
+  for (const key of Object.keys(factory)) LucentClass[key] = factory[key];
+  return LucentClass;
+}
+
+module.exports = { loadModule, lucentClass };

package/runtime/native/LucentNative.podspec

@@ -0,0 +1,28 @@
+# Generated by Lucent. Do not edit.
+Pod::Spec.new do |s|
+  s.name         = "LucentNative"
+  s.version      = "0.1.0"
+  s.summary      = "Native modules compiled by Lucent from *.lucent.ts"
+  s.homepage     = "https://github.com/Fausto95/lucent"
+  s.license      = "MIT"
+  s.authors      = "Lucent"
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/Fausto95/lucent.git", :tag => s.version.to_s }
+
+  # Projects with platform modules generate one set of files per target
+  # (cpp/generated/ios, cpp/generated/android); iOS builds its own. The
+  # runtime's Android glue is guarded by __ANDROID__.
+  s.source_files = ["cpp/**/*.{h,cpp,inc,c,mm}", "ios/**/*.{h,mm}"]
+  s.exclude_files = ["cpp/generated/android/**", "cpp/generated/host/**"]
+  s.frameworks   = "CoreFoundation"
+  s.header_mappings_dir = "cpp"
+  s.pod_target_xcconfig = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/cpp\" \"$(PODS_TARGET_SRCROOT)/cpp/generated/ios\" \"$(PODS_TARGET_SRCROOT)/cpp/generated\" \"$(PODS_TARGET_SRCROOT)/cpp/rn\"",
+    # The vendored regular expression engine (third_party/quickjs) is C.
+    "OTHER_CFLAGS" => "$(inherited) -w",
+    "OTHER_CPLUSPLUSFLAGS" => "$(inherited) -ffp-contract=off -fexceptions -frtti -Wno-gnu-statement-expression -Wno-unused-label -Wno-parentheses-equality -Wno-comma",
+  }
+
+  install_modules_dependencies(s)
+end

package/runtime/native/android/CMakeLists.txt

@@ -0,0 +1,51 @@
+# Built as part of the app's `appmodules` library through React Native's C++
+# module autolinking (see react-native.config.js).
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+set(LUCENT_ROOT ${CMAKE_CURRENT_LIST_DIR}/..)
+file(GLOB_RECURSE LUCENT_SOURCES CONFIGURE_DEPENDS ${LUCENT_ROOT}/cpp/*.cpp)
+# Projects with platform modules generate one set of files per target
+# (cpp/generated/ios, cpp/generated/android); Android builds its own.
+list(FILTER LUCENT_SOURCES EXCLUDE REGEX "/cpp/generated/(ios|host)/")
+
+# The vendored regular expression engine is C. It is a library of its own so
+# that React Native's C++ compile options never reach it.
+file(GLOB LUCENT_C_SOURCES CONFIGURE_DEPENDS ${LUCENT_ROOT}/cpp/third_party/quickjs/*.c)
+add_library(lucentregexp STATIC ${LUCENT_C_SOURCES})
+set_target_properties(lucentregexp PROPERTIES POSITION_INDEPENDENT_CODE ON C_STANDARD 11)
+target_compile_options(lucentregexp PRIVATE -w -O2)
+
+add_library(lucentnative OBJECT ${LUCENT_SOURCES})
+
+target_include_directories(lucentnative PUBLIC
+  ${LUCENT_ROOT}/cpp
+  ${LUCENT_ROOT}/cpp/generated/android
+  ${LUCENT_ROOT}/cpp/generated
+  ${LUCENT_ROOT}/cpp/rn
+  ${CMAKE_CURRENT_LIST_DIR}/include
+)
+
+if(COMMAND target_compile_reactnative_options)
+  target_compile_reactnative_options(lucentnative PRIVATE)
+endif()
+# Hidden: calls between the runtime's files are direct instead of through the
+# PLT of the app's shared library (a string argument made three such calls).
+# Natives are bound with RegisterNatives, so nothing is looked up by name.
+target_compile_options(lucentnative PRIVATE
+  -fvisibility=hidden
+  $<$<COMPILE_LANGUAGE:CXX>:-fvisibility-inlines-hidden>
+  $<$<COMPILE_LANGUAGE:CXX>:-std=c++20>
+  $<$<COMPILE_LANGUAGE:CXX>:-ffp-contract=off>
+  $<$<COMPILE_LANGUAGE:CXX>:-fexceptions>
+  $<$<COMPILE_LANGUAGE:CXX>:-frtti>
+  $<$<COMPILE_LANGUAGE:CXX>:-O2>
+  $<$<COMPILE_LANGUAGE:CXX>:-Wno-unused-parameter>
+  $<$<COMPILE_LANGUAGE:CXX>:-Wno-unused-variable>
+  $<$<COMPILE_LANGUAGE:CXX>:-Wno-unused-label>
+  $<$<COMPILE_LANGUAGE:CXX>:-Wno-gnu-statement-expression>
+  $<$<COMPILE_LANGUAGE:CXX>:-Wno-parentheses-equality>
+  $<$<COMPILE_LANGUAGE:CXX>:-Wno-comma>
+)
+
+target_link_libraries(lucentnative jsi reactnative fbjni log lucentregexp)

package/runtime/native/android/build.gradle

@@ -0,0 +1,22 @@
+// Generated by Lucent. Do not edit.
+// The Java Lucent's Android platform code needs (dev.lucent.NativeProxy); the
+// C++ is built into the app's appmodules library (CMakeLists.txt).
+apply plugin: "com.android.library"
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+  namespace "dev.lucent"
+  compileSdk safeExtGet("compileSdkVersion", 36)
+  defaultConfig {
+    minSdk safeExtGet("minSdkVersion", 24)
+    // Written by lucent build: what the JNI glue finds by name, kept from the app's shrinker.
+    consumerProguardFiles "consumer-rules.pro"
+  }
+}
+
+dependencies {
+  implementation("com.facebook.react:react-android")
+}

package/runtime/native/android/include/lucentnative.h

@@ -0,0 +1,16 @@
+// React Native's autolinking calls <libraryName>_ModuleProvider for Java
+// TurboModules. Lucent has none (its module is pure C++), so this returns null.
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+
+#include <memory>
+#include <string>
+
+namespace facebook::react {
+
+inline std::shared_ptr<TurboModule> lucentnative_ModuleProvider(const std::string&, const JavaTurboModule::InitParams&) {
+  return nullptr;
+}
+
+}  // namespace facebook::react

package/runtime/native/android/src/main/java/dev/lucent/LucentPackage.java

@@ -0,0 +1,25 @@
+// Generated by Lucent. Do not edit.
+package dev.lucent;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Lucent's module is C++ (autolinked through CMake). This package only lets
+ * autolinking include the Java Lucent's platform code needs (NativeProxy).
+ */
+public final class LucentPackage implements ReactPackage {
+  @Override
+  public List<NativeModule> createNativeModules(ReactApplicationContext context) {
+    return Collections.emptyList();
+  }
+
+  @Override
+  public List<ViewManager> createViewManagers(ReactApplicationContext context) {
+    return Collections.emptyList();
+  }
+}

package/runtime/native/android/src/main/java/dev/lucent/NativeProxy.java

@@ -0,0 +1,132 @@
+// Generated by Lucent. Do not edit.
+package dev.lucent;
+
+import android.os.Build;
+import android.util.Log;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+/**
+ * Java interfaces implemented by Lucent code: a java.lang.reflect.Proxy whose
+ * calls go to C++. One class serves every interface, so no Java is generated
+ * per interface. Methods are keyed by name and parameter descriptor
+ * (`onLocationChanged(Landroid/location/Location;)`), so overloads stay
+ * apart; default methods Lucent does not implement keep their Java body. The
+ * handle is a C++ object released when the proxy is collected.
+ */
+public final class NativeProxy implements InvocationHandler {
+  private final long handle;
+
+  private NativeProxy(long handle) {
+    this.handle = handle;
+  }
+
+  public static Object create(Class<?> iface, long handle) {
+    return Proxy.newProxyInstance(iface.getClassLoader(), new Class<?>[] {iface}, new NativeProxy(handle));
+  }
+
+  @Override
+  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+    if (method.getDeclaringClass() == Object.class) {
+      switch (method.getName()) {
+        case "equals":
+          return proxy == args[0];
+        case "hashCode":
+          return System.identityHashCode(proxy);
+        default:
+          return "Lucent " + proxy.getClass().getInterfaces()[0].getName();
+      }
+    }
+    String key = key(method);
+    Object[] a = args == null ? new Object[0] : args;
+    if (!has(handle, key) && method.isDefault()) return invokeDefault(proxy, method, a);
+    return call(handle, key, a);
+  }
+
+  /** Name and parameter descriptor, as JNI writes them. */
+  static String key(Method method) {
+    StringBuilder b = new StringBuilder(method.getName()).append('(');
+    for (Class<?> p : method.getParameterTypes()) b.append(descriptor(p));
+    return b.append(')').toString();
+  }
+
+  private static String descriptor(Class<?> c) {
+    if (c.isArray()) return "[" + descriptor(c.getComponentType());
+    if (c == int.class) return "I";
+    if (c == long.class) return "J";
+    if (c == boolean.class) return "Z";
+    if (c == double.class) return "D";
+    if (c == float.class) return "F";
+    if (c == short.class) return "S";
+    if (c == byte.class) return "B";
+    if (c == char.class) return "C";
+    if (c == void.class) return "V";
+    return "L" + c.getName().replace('.', '/') + ";";
+  }
+
+  /**
+   * A default method's own body: LocationListener's onLocationChanged(List),
+   * which the platform calls from API 31, loops over onLocationChanged(Location).
+   * A private lookup in the interface (API 33); the Lookup constructor Java 8
+   * code used (API 26 to 32); where neither works, the type's zero value, and
+   * the error is logged.
+   */
+  private static Object invokeDefault(Object proxy, Method method, Object[] args) throws Throwable {
+    Class<?> declaring = method.getDeclaringClass();
+    try {
+      MethodHandles.Lookup lookup;
+      if (Build.VERSION.SDK_INT >= 33) {
+        lookup = MethodHandles.privateLookupIn(declaring, MethodHandles.lookup());
+      } else {
+        Constructor<MethodHandles.Lookup> ctor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, int.class);
+        ctor.setAccessible(true);
+        lookup = ctor.newInstance(declaring, -1);
+      }
+      return lookup.unreflectSpecial(method, declaring).bindTo(proxy).invokeWithArguments(args);
+    } catch (ReflectiveOperationException | UnsupportedOperationException e) {
+      Log.e("Lucent", "cannot run the default body of " + method + " on this Android version", e);
+      return zero(method.getReturnType());
+    }
+  }
+
+  private static Object zero(Class<?> type) {
+    if (type == boolean.class) return false;
+    if (type == int.class) return 0;
+    if (type == long.class) return 0L;
+    if (type == double.class) return 0.0;
+    if (type == float.class) return 0f;
+    if (type == short.class) return (short) 0;
+    if (type == byte.class) return (byte) 0;
+    if (type == char.class) return (char) 0;
+    return null;
+  }
+
+  @Override
+  @SuppressWarnings({"deprecation", "removal"})
+  protected void finalize() throws Throwable {
+    try {
+      release(handle);
+    } finally {
+      super.finalize();
+    }
+  }
+
+  /** For generated subclasses of SDK classes: a call of their Lucent side. */
+  public static Object dispatch(long handle, String key, Object[] args) {
+    return call(handle, key, args);
+  }
+
+  /** For generated subclasses: their Lucent side is released with them. */
+  public static void releaseHandle(long handle) {
+    release(handle);
+  }
+
+  private static native boolean has(long handle, String key);
+
+  private static native Object call(long handle, String key, Object[] args);
+
+  private static native void release(long handle);
+}

package/runtime/native/ios/LucentRegistration.mm

@@ -0,0 +1,23 @@
+// Registers the Lucent C++ TurboModule when the binary loads, so React Native
+// finds it without codegen or any change to the app delegate.
+#import <Foundation/Foundation.h>
+
+#include <ReactCommon/CxxTurboModuleUtils.h>
+
+#include "LucentModule.h"
+
+@interface LucentRegistration : NSObject
+@end
+
+@implementation LucentRegistration
+
++ (void)load
+{
+  facebook::react::registerCxxModuleToGlobalModuleMap(
+      std::string(facebook::react::LucentModule::kModuleName),
+      [](std::shared_ptr<facebook::react::CallInvoker> jsInvoker) {
+        return std::make_shared<facebook::react::LucentModule>(std::move(jsInvoker));
+      });
+}
+
+@end

package/runtime/native/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "lucent",
+  "version": "0.1.0",
+  "private": true,
+  "description": "Generated by Lucent. Do not edit."
+}

package/runtime/native/react-native.config.js

@@ -0,0 +1,19 @@
+// Generated by Lucent. Do not edit.
+// Android builds cpp/ through CMake autolinking (C++ module), and the Java in
+// android/ (dev.lucent.NativeProxy) as a library; iOS builds through the podspec.
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: "android",
+        packageImportPath: "import dev.lucent.LucentPackage;",
+        packageInstance: "new LucentPackage()",
+        libraryName: "lucentnative",
+        cxxModuleCMakeListsModuleName: "lucentnative",
+        cxxModuleCMakeListsPath: "CMakeLists.txt",
+        cxxModuleHeaderName: "LucentModule",
+      },
+      ios: {},
+    },
+  },
+};