peachsim 0.1.1620 → 0.1.1635

package/src/native-firebase-config.ts

@@ -106,6 +106,172 @@ export async function readExpoConfigAsync(
   }
 }
 
+// a launch method may guard configure() with the safe-configure idiom: an
+// `if` whose comma-separated clauses read the bundled GoogleService-Info.plist
+// and test its API_KEY prefix. every clause is evaluated against the plist the
+// target ships, so the answer is the one native launch reaches. any other
+// condition cannot be proven and stays refused.
+function evaluateFirebaseGuard(header: string, resources: string[]): boolean | null {
+  const condition = header.replace(/^\s*if\b/, '').replace(/\{\s*$/, '')
+  const clauses: string[] = []
+  let depth = 0
+  let start = 0
+  let quoted = false
+  for (let index = 0; index < condition.length; index++) {
+    const char = condition[index]
+    if (char === '"') quoted = !quoted
+    if (quoted) continue
+    if (char === '(' || char === '[') depth += 1
+    if (char === ')' || char === ']') depth -= 1
+    if (char === ',' && depth === 0) {
+      clauses.push(condition.slice(start, index).trim())
+      start = index + 1
+    }
+  }
+  clauses.push(condition.slice(start).trim())
+  const sources = resources.filter(
+    (file) => path.basename(file) === 'GoogleService-Info.plist',
+  )
+  const bound = new Map<string, unknown>()
+  for (const clause of clauses) {
+    if (/^FirebaseApp\s*\.\s*app\s*\(\s*\)\s*==\s*nil$/.test(clause)) continue
+    const resource =
+      /^let\s+(\w+)\s*=\s*Bundle\.main\.path\s*\(\s*forResource:\s*"GoogleService-Info"\s*,\s*ofType:\s*"plist"\s*\)$/.exec(
+        clause,
+      )
+    if (resource) {
+      if (sources.length !== 1) return false
+      bound.set(resource[1], sources[0])
+      continue
+    }
+    const dictionary =
+      /^let\s+(\w+)\s*=\s*NSDictionary\s*\(\s*contentsOfFile:\s*(\w+)\s*\)$/.exec(clause)
+    if (dictionary && typeof bound.get(dictionary[2]) === 'string') {
+      const parsed = parsePlistSource(
+        fs.readFileSync(String(bound.get(dictionary[2])), 'utf8'),
+      )
+      if (!isRecord(parsed)) return false
+      bound.set(dictionary[1], parsed)
+      continue
+    }
+    const entry = /^let\s+(\w+)\s*=\s*(\w+)\s*\[\s*"(\w+)"\s*\]\s+as\?\s+String$/.exec(
+      clause,
+    )
+    const dictionaryValue = entry ? bound.get(entry[2]) : undefined
+    if (entry && isRecord(dictionaryValue)) {
+      const value = dictionaryValue[entry[3]]
+      if (typeof value !== 'string') return false
+      bound.set(entry[1], value)
+      continue
+    }
+    const prefix = /^(\w+)\.hasPrefix\s*\(\s*"([^"]*)"\s*\)$/.exec(clause)
+    const subject = prefix ? bound.get(prefix[1]) : undefined
+    if (prefix && typeof subject === 'string') {
+      if (!subject.startsWith(prefix[2])) return false
+      continue
+    }
+    return null
+  }
+  return true
+}
+
+// native source with comments and string contents blanked in place, so brace
+// and keyword scans see only code and offsets still index the raw text.
+function blankSwiftObjcLiterals(raw: string) {
+  return raw.replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*|"(?:\\.|[^"\\])*"/g, (token) =>
+    token.startsWith('"')
+      ? `"${' '.repeat(token.length - 2)}"`
+      : token.replace(/[^\n]/g, ' '),
+  )
+}
+
+// the text of the brace block opening at `open`, and the index after its end.
+function braceBlock(source: string, open: number) {
+  let depth = 0
+  for (let index = open; index < source.length; index += 1) {
+    if (source[index] === '{') depth += 1
+    if (source[index] === '}') depth -= 1
+    if (depth === 0) return { body: source.slice(open + 1, index), end: index + 1 }
+  }
+  return null
+}
+
+// whether every path through the code configures the default Firebase app: a
+// top-level configure call, or an if/else chain ending in else whose blocks each
+// do.
+function configuresDefaultApp(code: string): boolean {
+  const configureCall = /\bFirebaseApp\s*\.\s*configure\s*\(/
+  let topLevel = ''
+  let depth = 0
+  for (const char of code) {
+    if (char === '{') depth += 1
+    if (depth === 0) topLevel += char
+    if (char === '}') depth -= 1
+  }
+  if (configureCall.test(topLevel)) return true
+  for (const chain of code.matchAll(/\bif\b[^{]*\{/g)) {
+    let open = chain.index + chain[0].length - 1
+    const blocks: string[] = []
+    let complete = false
+    for (;;) {
+      const block = braceBlock(code, open)
+      if (!block) break
+      blocks.push(block.body)
+      const next = /^\s*else\s*(if\b[^{]*)?\{/.exec(code.slice(block.end))
+      if (!next) break
+      open = block.end + next[0].length - 1
+      if (!next[1]) {
+        const last = braceBlock(code, open)
+        if (last) {
+          blocks.push(last.body)
+          complete = true
+        }
+        break
+      }
+    }
+    if (complete && blocks.every(configuresDefaultApp)) return true
+  }
+  return false
+}
+
+// where a launch method configures the default Firebase app: directly, or by
+// calling a static no-argument function of an app target type whose body
+// configures it on every path. returns a match-like result carrying the call's
+// index, or null.
+function findDefaultConfigureCall(body: string, sources: readonly string[]) {
+  const direct =
+    /^\s*(?:FirebaseApp\s*\.\s*configure\s*\(\s*\)|\[FIRApp\s+configure\])/m.exec(body)
+  if (direct) return direct
+  for (const call of body.matchAll(/^\s*([A-Z]\w*)\s*\.\s*(\w+)\s*\(\s*\)/gm)) {
+    const [, type, name] = call
+    for (const file of sources) {
+      if (!file.endsWith('.swift')) continue
+      const source = blankSwiftObjcLiterals(fs.readFileSync(file, 'utf8'))
+      const declaration = new RegExp(
+        `\\b(?:enum|struct|class)\\s+${type}\\b[^{]*\\{`,
+      ).exec(source)
+      if (!declaration) continue
+      const owner = braceBlock(source, declaration.index + declaration[0].length - 1)
+      const method = owner
+        ? new RegExp(`\\bstatic\\s+func\\s+${name}\\s*\\(\\s*\\)[^{]*\\{`).exec(
+            owner.body,
+          )
+        : null
+      const helper =
+        owner && method
+          ? braceBlock(owner.body, method.index + method[0].length - 1)
+          : null
+      if (
+        helper &&
+        !/\b(?:return|throw)\b/.test(helper.body) &&
+        configuresDefaultApp(helper.body)
+      )
+        return call
+    }
+  }
+  return null
+}
+
 // the GoogleService-Info.plist an app target's launch method configures as the
 // default app, relative to the project root, or null when it configures none.
 function readTargetGoogleServicesFile(
@@ -120,27 +286,43 @@ function readTargetGoogleServicesFile(
     /^AppDelegate\.(swift|mm|m)$/.test(path.basename(file)),
   )
   const defaultConfigured = delegates.some((file) => {
-    const source = fs
-      .readFileSync(file, 'utf8')
-      .replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*|"(?:\\.|[^"\\])*"/g, (token) =>
-        token.startsWith('"') ? '""' : token.replace(/[^\n]/g, ' '),
-      )
+    const raw = fs.readFileSync(file, 'utf8')
+    const source = blankSwiftObjcLiterals(raw)
     const launch =
       /(?:\bfunc\s+application\s*\([\s\S]*?didFinishLaunchingWithOptions[\s\S]*?\)\s*->\s*Bool|^-\s*\(BOOL\)\s*application\s*:[\s\S]*?didFinishLaunchingWithOptions[^{]*)\s*\{/m.exec(
         source,
       )
     if (!launch) return false
-    const body = source.slice(launch.index + launch[0].length)
-    const configure =
-      /^\s*(?:FirebaseApp\s*\.\s*configure\s*\(\s*\)|\[FIRApp\s+configure\])/m.exec(body)
+    const bodyStart = launch.index + launch[0].length
+    const body = source.slice(bodyStart)
+    const configure = findDefaultConfigureCall(body, app.allSources)
     if (!configure) return false
-    const before = body.slice(0, configure.index)
+    let before = body.slice(0, configure.index)
     let depth = 1
-    for (const token of before) {
-      if (token === '{') depth += 1
+    let guardOpen = -1
+    for (let index = 0; index < before.length; index++) {
+      const token = before[index]
+      if (token === '{') {
+        depth += 1
+        if (depth === 2) guardOpen = index
+      }
       if (token === '}') depth -= 1
       if (depth === 0) return false
     }
+    let guard: string | null = null
+    if (depth === 2) {
+      const headers = [...before.slice(0, guardOpen).matchAll(/^[ \t]*if\b/gm)]
+      const header = headers.at(-1)
+      if (header) {
+        guard = raw.slice(bodyStart + header.index, bodyStart + guardOpen + 1)
+        before = before.slice(0, header.index)
+        depth = 1
+        for (const token of before) {
+          if (token === '{') depth += 1
+          if (token === '}') depth -= 1
+        }
+      }
+    }
     let conditionalDepth = 0
     for (const directive of before.matchAll(
       /^\s*#\s*(if|ifdef|ifndef|elseif|elif|else|endif)\b/gm,
@@ -155,11 +337,25 @@ function readTargetGoogleServicesFile(
         conditionalDepth -= 1
       }
     }
-    if (depth !== 1 || conditionalDepth !== 0 || /\b(?:return|throw)\b/.test(before))
+    // a return inside a nested closure leaves the launch method running
+    let topLevelBefore = ''
+    let nesting = 0
+    for (const token of before) {
+      if (token === '{') nesting += 1
+      if (nesting === 0) topLevelBefore += token
+      if (token === '}') nesting -= 1
+    }
+    const guarded = guard === null ? true : evaluateFirebaseGuard(guard, app.resources)
+    if (
+      guarded === null ||
+      depth !== 1 ||
+      conditionalDepth !== 0 ||
+      /\b(?:return|throw)\b/.test(topLevelBefore)
+    )
       throw new Error(
         'native Firebase initialization must be unconditional in the app launch method',
       )
-    return true
+    return guarded
   })
   if (!defaultConfigured) return null
   const resources = app.resources.filter((file) =>

package/src/nitro-compile.ts

@@ -20,10 +20,7 @@ export function collectNitroCompileInput(
 ): { input: SwiftCompileInput; collection: NitroSourceCollection } {
   const collection = collectNitroSources(options)
   const files = { ...collection.files }
-  const platform = path.join(
-    options.moduleRoot,
-    'platform/react-native-nitro-modules',
-  )
+  const platform = path.join(options.moduleRoot, 'platform/react-native-nitro-modules')
   const read = (file: string) =>
     readPackageFile(
       platform,
@@ -71,7 +68,7 @@ export function collectNitroCompileInput(
     'let package = Package(name: "PeachNativeModule", targets: [',
     ...collection.targets.map(
       (target) =>
-        `.target(name: ${JSON.stringify(target.name)}, dependencies: ${JSON.stringify(target.dependencies?.map((dependency) => dependency.name) ?? [])}, path: ${JSON.stringify(target.path)}, cxxSettings: [.define("DEBUG")]),`,
+        `.target(name: ${JSON.stringify(target.name)}, dependencies: ${JSON.stringify(target.dependencies?.map((dependency) => dependency.name) ?? [])}, path: ${JSON.stringify(target.path)}, ${target.cxxInterop ? 'swiftSettings: [.interoperabilityMode(.Cxx)]' : 'cxxSettings: [.define("DEBUG")]'}),`,
     ),
     `.target(name: "${runtime}", dependencies: ["JsiBridge", "NitroCore"], cxxSettings: [.define("DEBUG")]),`,
     `.executableTarget(name: "PeachNitroApp", dependencies: ["${runtime}", "${implementation.name}"], swiftSettings: [.interoperabilityMode(.Cxx)]),`,

package/src/nitro-source.ts

@@ -55,61 +55,72 @@ function packageInfo(root: string): NitroSourceCollection['packages'][number] {
   return { name: value.name, version: value.version, root }
 }
 
-function registrations(root: string): {
-  namespace: string
-  classes: { name: string; implementation: string }[]
-} {
-  const config = readJson(root, 'nitro.json')
-  if (
-    !object(config) ||
-    !Array.isArray(config.cxxNamespace) ||
-    !config.cxxNamespace.every(
-      (part): part is string =>
-        typeof part === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(part),
-    ) ||
-    !object(config.autolinking)
-  )
-    throw new Error(`${root}: invalid Nitro C++ namespace or autolinking config`)
-  const classes: { name: string; implementation: string }[] = []
-  for (const [name, entry] of Object.entries(config.autolinking).sort(([a], [b]) =>
-    a.localeCompare(b),
+function registrations(root: string) {
+  // cocoapods compiles this generated initializer through +autolinking.rb.
+  // nitro.json is a generator input and need not ship in the package.
+  const directory = path.join(root, 'nitrogen/generated/ios')
+  const initializers = fs
+    .readdirSync(directory)
+    .filter((file) => file.endsWith('Autolinking.mm'))
+  if (initializers.length !== 1)
+    throw new Error(`${root}: expected one generated Nitro iOS initializer`)
+  const source = readPackageFile(
+    root,
+    path.join(directory, initializers[0]!),
+    MAX_SWIFT_COMPILE_SOURCE_BYTES,
+  ).toString('utf8')
+  const namespaces = [
+    ...source.matchAll(/\busing namespace (margelo::nitro(?:::[A-Za-z_]\w*)*)\s*;/g),
+  ]
+  const namespace = namespaces[1]?.[1]
+  if (namespaces.length !== 2 || namespaces[0]?.[1] !== 'margelo::nitro' || !namespace)
+    throw new Error(`${root}: invalid generated Nitro C++ namespace`)
+
+  const classes: (
+    | { name: string; implementation: string; language: 'c++' }
+    | { name: string; language: 'swift' }
+  )[] = []
+  let swiftModule: string | null = null
+  for (const registration of source.matchAll(
+    /\bHybridObjectRegistry::registerHybridObjectConstructor\(\s*("(?:[^"\\]|\\.)*")\s*,\s*\[\]\(\)\s*->\s*std::shared_ptr<HybridObject>\s*\{([\s\S]*?)\}\s*\);/g,
   )) {
-    if (!object(entry)) throw new Error(`${root}: invalid Nitro autolinking ${name}`)
-    // platform-specific registrations cannot be substituted for shared C++.
-    // report their actual language instead of silently dropping Swift or JNI.
-    if (
-      !object(entry.all) ||
-      entry.all.language !== 'c++' ||
-      Object.keys(entry).some((platform) => platform !== 'all')
-    ) {
-      const languages = Object.entries(entry).map(
-        ([platform, value]) =>
-          `${platform}:${object(value) ? String(value.language) : 'invalid'}`,
-      )
-      throw new Error(
-        `${root}: unsupported Nitro module ${name} (${languages.join(', ')}); ` +
-          'this collector supports shared all.language=c++ only, not Swift, Kotlin, Java or JNI',
+    const name: unknown = JSON.parse(registration[1]!)
+    const body = registration[2]!
+    if (typeof name !== 'string' || name.length === 0)
+      throw new Error(`${root}: invalid generated Nitro registration name`)
+    const cpp = /return\s+std::make_shared<([A-Za-z_]\w*)>\(\);/.exec(body)
+    const swift =
+      /=\s*([A-Za-z_]\w*)::([A-Za-z_]\w*)::create([A-Za-z_]\w*)\(\);\s*return hybridObject;/.exec(
+        body,
       )
+    if (cpp && !swift) {
+      classes.push({ name, implementation: cpp[1]!, language: 'c++' })
+    } else if (
+      swift &&
+      !cpp &&
+      swift[2] === `${swift[1]}Autolinking` &&
+      swift[3] === name &&
+      (swiftModule === null || swiftModule === swift[1])
+    ) {
+      swiftModule = swift[1]!
+      classes.push({ name, language: 'swift' })
+    } else {
+      throw new Error(`${root}: unsupported generated Nitro iOS registration ${name}`)
     }
-    const implementation = entry.all.implementationClassName
-    if (
-      name.length === 0 ||
-      typeof implementation !== 'string' ||
-      !/^[A-Za-z_][A-Za-z0-9_]*$/.test(implementation)
-    )
-      throw new Error(`${root}: invalid Nitro C++ implementation for ${name}`)
-    classes.push({ name, implementation })
-  }
-  if (classes.length === 0) throw new Error(`${root}: no Nitro C++ registrations`)
-  return {
-    namespace: ['margelo', 'nitro', ...config.cxxNamespace].join('::'),
-    classes,
   }
+  const count = [
+    ...source.matchAll(/\bHybridObjectRegistry::registerHybridObjectConstructor\s*\(/g),
+  ].length
+  if (classes.length === 0 || classes.length !== count)
+    throw new Error(`${root}: incomplete generated Nitro iOS registrations`)
+  if (new Set(classes.map(({ name }) => name)).size !== classes.length)
+    throw new Error(`${root}: duplicate generated Nitro iOS registration`)
+  classes.sort((a, b) => a.name.localeCompare(b.name))
+  return { namespace, swiftModule, classes }
 }
 
-/** collect installed C++ bodies, Nitro core and RN's JSI, without reading or
- * rewriting package JavaScript. views and platform implementations are outside
- * this C++ module collector; the caller must supply real platform bindings. */
+/** collect installed native bodies, generated bridges, Nitro core and RN's
+ * JSI without reading or rewriting package JavaScript. */
 export function collectNitroSources(options: NitroSourceOptions): NitroSourceCollection {
   const module = packageInfo(options.packageRoot)
   const config = registrations(module.root)
@@ -189,6 +200,7 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
     includeNamespace: string | null,
     skip: ReadonlySet<string> = new Set(),
     select: (file: string) => boolean = () => true,
+    extensions: RegExp = /\.(?:c|cc|cpp|cxx|h|hpp|hxx|inl)$/,
   ) => {
     const headers = new Map<string, string>()
     const walk = (relative: string) => {
@@ -204,7 +216,7 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
           walk(sourceRelative)
           continue
         }
-        if (!/\.(?:c|cc|cpp|cxx|h|hpp|hxx|inl)$/.test(entry.name)) continue
+        if (!extensions.test(entry.name)) continue
         if (!select(entry.name)) continue
         if (/[\p{Cc}"\\]/u.test(sourceRelative))
           throw new Error(`invalid Nitro source path: ${sourceRelative}`)
@@ -259,13 +271,72 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
     (file) => (file.endsWith('.h') && file !== 'JSIDynamic.h') || file === 'jsi.cpp',
   )
   collect(nitro.root, 'cpp', coreTarget, 'NitroModules', new Set(['views']))
-  const implementationHeaders = collect(module.root, 'cpp', targetName, null)
+  const implementationHeaders = fs.existsSync(path.join(module.root, 'cpp'))
+    ? collect(module.root, 'cpp', targetName, null)
+    : new Map<string, string>()
   collect(module.root, 'nitrogen/generated/shared/c++', targetName, null)
-  for (const { implementation } of config.classes)
-    if (!implementationHeaders.has(`${implementation}.hpp`))
+  for (const entry of config.classes)
+    if (
+      entry.language === 'c++' &&
+      !implementationHeaders.has(`${entry.implementation}.hpp`)
+    )
       throw new Error(
-        `${module.root}: missing C++ implementation header ${implementation}.hpp`,
+        `${module.root}: missing C++ implementation header ${entry.implementation}.hpp`,
+      )
+
+  if (config.swiftModule) {
+    for (const directory of ['ios/core', 'ios/utils'])
+      collect(
+        nitro.root,
+        directory,
+        coreTarget,
+        'NitroModules',
+        new Set(),
+        (file) => !file.endsWith('.swift'),
       )
+    const nitroSwift = target('NitroModules', [coreTarget, jsiTarget])
+    nitroSwift.cxxInterop = true
+    const packageSwift = target(config.swiftModule, [targetName, 'NitroModules'])
+    packageSwift.cxxInterop = true
+    result.targets.push(nitroSwift, packageSwift)
+    for (const directory of ['ios/core', 'ios/utils', 'ios/views'])
+      collect(
+        nitro.root,
+        directory,
+        'NitroModules',
+        null,
+        new Set(['HybridView.swift']),
+        () => true,
+        /\.swift$/,
+      )
+    add(
+      `${targetPath('NitroModules')}/PeachNitroExports.swift`,
+      `@_exported import ${coreTarget}\n`,
+    )
+    collect(
+      module.root,
+      'ios',
+      config.swiftModule,
+      null,
+      new Set(['Tests']),
+      () => true,
+      /\.swift$/,
+    )
+    collect(
+      module.root,
+      'nitrogen/generated/ios',
+      config.swiftModule,
+      null,
+      new Set(),
+      () => true,
+      /\.swift$/,
+    )
+    collect(module.root, 'nitrogen/generated/ios', targetName, null)
+    add(
+      `${targetPath(config.swiftModule)}/PeachNitroExports.swift`,
+      `@_exported import ${targetName}\n`,
+    )
+  }
 
   // explicit module maps avoid importing every RN view or private JSI header.
   add(
@@ -274,7 +345,7 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
   )
   add(
     `${targetPath(coreTarget)}/include/module.modulemap`,
-    `module ${coreTarget} { header "NitroModules/InstallNitro.hpp" export * }\n`,
+    `module ${coreTarget} { header "NitroModules/InstallNitro.hpp"${config.swiftModule ? ['ArrayBufferHolder.hpp', 'AnyMapUtils.hpp', 'PromiseHolder.hpp', 'Result.hpp', 'RuntimeError.hpp', 'DateToChronoDate.hpp'].map((header) => ` header "NitroModules/${header}"`).join('') : ''} export * }\n`,
   )
   add(
     result.registration.header,
@@ -282,7 +353,7 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
   )
   add(
     `${targetPath(targetName)}/include/module.modulemap`,
-    `module ${targetName} { header "PeachNitroRegistration.hpp" export * }\n`,
+    `module ${targetName} { header "PeachNitroRegistration.hpp"${config.swiftModule ? ` header "${config.swiftModule}-Swift-Cxx-Bridge.hpp"` : ''} export * }\n`,
   )
   add(
     `${targetPath(targetName)}/PeachNitroRegistration.cpp`,
@@ -291,15 +362,28 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
       '#include <NitroModules/HybridObjectRegistry.hpp>',
       '#include <memory>',
       '#include <type_traits>',
-      ...[...new Set(config.classes.map(({ implementation }) => implementation))].map(
-        (implementation) => `#include "${implementation}.hpp"`,
-      ),
+      ...(config.swiftModule
+        ? [`#include "${config.swiftModule}-Swift-Cxx-Umbrella.hpp"`]
+        : []),
+      ...[
+        ...new Set(
+          config.classes
+            .filter((entry) => entry.language === 'c++')
+            .map(({ implementation }) => implementation),
+        ),
+      ].map((implementation) => `#include "${implementation}.hpp"`),
       `extern "C" void ${result.registration.symbol}() {`,
-      ...config.classes.flatMap(({ name, implementation }) => [
-        `  static_assert(std::is_default_constructible_v<${config.namespace}::${implementation}>);`,
+      ...config.classes.flatMap((entry) => [
+        ...(entry.language === 'c++'
+          ? [
+              `  static_assert(std::is_default_constructible_v<${config.namespace}::${entry.implementation}>);`,
+            ]
+          : []),
         '  margelo::nitro::HybridObjectRegistry::registerHybridObjectConstructor(',
-        `    ${JSON.stringify(name)}, []() -> std::shared_ptr<margelo::nitro::HybridObject> {`,
-        `      return std::make_shared<${config.namespace}::${implementation}>();`,
+        `    ${JSON.stringify(entry.name)}, []() -> std::shared_ptr<margelo::nitro::HybridObject> {`,
+        entry.language === 'swift'
+          ? `      return ${config.swiftModule}::${config.swiftModule}Autolinking::create${entry.name}();`
+          : `      return std::make_shared<${config.namespace}::${entry.implementation}>();`,
         '    });',
       ]),
       '}',