react-native-enriched-markdown-scaffold 0.7.4-scaffold.9 → 1.0.2-scaffold.2

package/cpp/highlight/CodeBlockLanguages.cpp

@@ -0,0 +1,138 @@
+#include "CodeBlockLanguages.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cctype>
+#include <cstring>
+
+namespace Markdown {
+
+namespace {
+
+struct LanguageName {
+  const char *key;
+  const char *name;
+  // Canonical tree-sitter grammar id (vendored directory name), or "" when no
+  // grammar covers this fence language.
+  const char *grammar;
+};
+
+// Sorted by key; both lookups below binary-search this table.
+constexpr std::array<LanguageName, 42> kLanguageNames{{
+    {"bash", "Bash", "bash"},
+    {"c", "C", "c"},
+    {"cc", "C++", "cpp"},
+    {"cpp", "C++", "cpp"},
+    {"cs", "C#", "c-sharp"},
+    {"csharp", "C#", "c-sharp"},
+    {"css", "CSS", "css"},
+    {"cxx", "C++", "cpp"},
+    {"dockerfile", "Dockerfile", ""},
+    {"go", "Go", "go"},
+    {"golang", "Go", "go"},
+    {"graphql", "GraphQL", ""},
+    {"html", "HTML", "html"},
+    {"java", "Java", "java"},
+    {"javascript", "JavaScript", "javascript"},
+    {"js", "JavaScript", "javascript"},
+    {"json", "JSON", "json"},
+    {"jsx", "JSX", "javascript"},
+    {"markdown", "Markdown", "markdown"},
+    {"md", "Markdown", "markdown"},
+    {"objc", "Objective-C", ""},
+    {"objectivec", "Objective-C", ""},
+    {"php", "PHP", "php"},
+    {"py", "Python", "python"},
+    {"python", "Python", "python"},
+    {"rb", "Ruby", "ruby"},
+    {"rs", "Rust", "rust"},
+    {"ruby", "Ruby", "ruby"},
+    {"rust", "Rust", "rust"},
+    {"scss", "SCSS", ""},
+    {"sh", "Shell", "bash"},
+    {"shell", "Shell", "bash"},
+    {"sql", "SQL", ""},
+    {"swift", "Swift", "swift"},
+    {"toml", "TOML", ""},
+    {"ts", "TypeScript", "typescript"},
+    {"tsx", "TSX", "tsx"},
+    {"typescript", "TypeScript", "typescript"},
+    {"xml", "XML", ""},
+    {"yaml", "YAML", "yaml"},
+    {"yml", "YAML", "yaml"},
+    {"zsh", "Zsh", "bash"},
+}};
+
+// findLanguage binary-searches kLanguageNames, so the table must be strictly
+// ascending by key under C strcmp order. Enforce it at compile time: a
+// misordered entry (e.g. "ruby" before "rs") would otherwise silently fail the
+// lookup and leave that language unhighlighted.
+constexpr bool keyLess(const char *a, const char *b) {
+  for (std::size_t i = 0;; ++i) {
+    unsigned char ca = static_cast<unsigned char>(a[i]);
+    unsigned char cb = static_cast<unsigned char>(b[i]);
+    if (ca != cb) {
+      return ca < cb;
+    }
+    if (ca == '\0') {
+      return false;
+    }
+  }
+}
+
+constexpr bool languageTableIsSorted() {
+  for (std::size_t i = 1; i < kLanguageNames.size(); ++i) {
+    if (!keyLess(kLanguageNames[i - 1].key, kLanguageNames[i].key)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static_assert(languageTableIsSorted(), "kLanguageNames must be sorted by key for binary search");
+
+// Lowercases language and binary-searches the table. Returns nullptr on miss.
+const LanguageName *findLanguage(const std::string &language, std::string &lowerOut) {
+  lowerOut = language;
+  for (char &c : lowerOut) {
+    c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+  }
+
+  auto it =
+      std::lower_bound(kLanguageNames.begin(), kLanguageNames.end(), lowerOut.c_str(),
+                       [](const LanguageName &entry, const char *key) { return std::strcmp(entry.key, key) < 0; });
+  if (it != kLanguageNames.end() && lowerOut == it->key) {
+    return &(*it);
+  }
+  return nullptr;
+}
+
+} // namespace
+
+std::string displayNameForLanguage(const std::string &language) {
+  if (language.empty()) {
+    return "";
+  }
+
+  std::string lower;
+  if (const LanguageName *entry = findLanguage(language, lower)) {
+    return entry->name;
+  }
+
+  lower[0] = static_cast<char>(std::toupper(static_cast<unsigned char>(lower[0])));
+  return lower;
+}
+
+std::string canonicalGrammarId(const std::string &language) {
+  if (language.empty()) {
+    return "";
+  }
+
+  std::string lower;
+  if (const LanguageName *entry = findLanguage(language, lower)) {
+    return entry->grammar;
+  }
+  return "";
+}
+
+} // namespace Markdown

package/cpp/highlight/CodeBlockLanguages.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <string>
+
+// Display names for code block fence languages, shared by every platform and
+// both markdown flavors so a fence like ```python is labeled identically
+// everywhere. Unlike the highlighting seam this is always compiled; it does
+// not depend on ENRICHED_MARKDOWN_CODE_HIGHLIGHT.
+
+namespace Markdown {
+
+// Maps a fence info string (for example "python", "js") to a human readable
+// display name ("Python", "JavaScript"). Unknown languages fall back to the
+// lowercased input with the first ASCII letter capitalized. Empty input
+// returns an empty string.
+std::string displayNameForLanguage(const std::string& language);
+
+// Maps a fence info string to the canonical tree-sitter grammar id that can
+// highlight it (for example "js" and "jsx" both map to "javascript"), or an
+// empty string when no grammar covers the language. The id is the vendored
+// grammar directory name; whether that grammar is actually compiled into the
+// build is answered separately by findGrammar.
+std::string canonicalGrammarId(const std::string& language);
+
+} // namespace Markdown

package/cpp/highlight/HighlightGrammars.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+// Registry of the tree-sitter grammars compiled into this build. The table and
+// the findGrammar definition live in generated_registry.cpp, emitted by
+// vendor/gen-registry.mjs for exactly the selected language subset, so this
+// header never references symbols for grammars that were not compiled.
+//
+// Only meaningful when ENRICHED_MARKDOWN_CODE_HIGHLIGHT is defined; without the
+// flag neither this header nor generated_registry.cpp is compiled.
+
+struct TSLanguage;
+
+namespace Markdown {
+
+struct GrammarEntry {
+  // Canonical grammar id, matching canonicalGrammarId() in CodeBlockLanguages.
+  const char *canonicalId;
+  // tree-sitter language constructor (extern "C" tree_sitter_<id>).
+  const TSLanguage *(*language)(void);
+  // The grammar's highlights.scm, inheritance already inlined, as a C string.
+  const char *highlightsQuery;
+};
+
+// Returns the entry for canonicalId, or nullptr when no grammar for it was
+// compiled into this build (unselected language) or canonicalId is empty.
+const GrammarEntry *findGrammar(const char *canonicalId);
+
+} // namespace Markdown

package/cpp/highlight/code_highlight_podspec.rb

@@ -0,0 +1,211 @@
+# Shared tree-sitter code-highlighting wiring for both podspecs
+# (EnrichedMarkdownCore in the monorepo, ReactNativeEnrichedMarkdown when
+# published without the core pod). Podspecs are imperative Ruby that own their
+# own source_files/defines/header paths, so unlike Android there is no build
+# ownership problem: this computes exactly what to add.
+#
+# Only lib.c (the runtime) and each selected grammar's parser.c/scanner.c are
+# compiled; every other vendored .c/.h is include-only and resolves through
+# quoted relative includes, so the shared HEADER_SEARCH_PATHS never carries a
+# grammar dir or tree-sitter/src (which would collide grammar parser.h files).
+#
+# The default grammar set is NOT hardcoded here: it is derived from the single
+# source of truth, vendor/grammar-versions.json (every grammar with default:true),
+# so the compiled sources always match the registry that gen-registry generates
+# from the same manifest. The Android build derives it the same way.
+
+require 'json'
+
+module EnrichedMarkdownConfig
+  @warnings_emitted = {}
+
+  def self.warn_once(key, message)
+    return if @warnings_emitted[key]
+    @warnings_emitted[key] = true
+    Pod::UI.warn message
+  end
+
+  # The consumer app's package.json "enriched-markdown" block is the build-time
+  # source of truth for feature toggles (mirrors the Android build.gradle and
+  # react-native-worklets). It is read from the Podfile's installation root --
+  # "<app>/package.json", one level above the "<app>/ios" dir CocoaPods installs
+  # into -- so in a monorepo it resolves to the app being built, not the workspace
+  # root. Per-app config therefore works; the download side (postinstall) is a
+  # separate, install-time decision. ENV vars remain a deprecated fallback.
+  #
+  # A cheap accessor over the memoized package.json (see consumer_package_json), so both
+  # this file (code highlighting) and the main podspec (math) can read it without re-parsing.
+  def self.consumer_config
+    config = consumer_package_json['enriched-markdown']
+    config.is_a?(Hash) ? config : {}
+  end
+
+  # A filesystem-safe identifier for the app being built, derived from its package.json
+  # "name" (falling back to the app directory name). It keys the per-app generated
+  # code-highlight registry (generated-<slug>) so that, in a hoisted monorepo, two apps
+  # with different custom language sets each get their own registry instead of clobbering
+  # a single shared one.
+  def self.consumer_app_slug
+    name = consumer_package_json['name'].to_s
+    name = File.basename(File.dirname(Pod::Config.instance.installation_root.to_s)) if name.empty?
+    slug = name.gsub(%r{[^A-Za-z0-9._-]+}, '-').gsub(/\A-+|-+\z/, '')
+    slug.empty? ? 'app' : slug
+  end
+
+  def self.consumer_package_json
+    return @consumer_package_json if defined?(@consumer_package_json)
+    @consumer_package_json = load_consumer_package_json
+  end
+
+  def self.load_consumer_package_json
+    path = File.join(Pod::Config.instance.installation_root.to_s, '..', 'package.json')
+    return {} unless File.exist?(path)
+    JSON.parse(File.read(path))
+  rescue StandardError => e
+    Pod::UI.warn "[ReactNativeEnrichedMarkdown] could not read the app package.json " \
+      "(#{e.message}); using defaults."
+    {}
+  end
+end
+
+module EnrichedMarkdownCodeHighlight
+  # Locate grammar-versions.json in both layouts, mirroring how gen-registry.mjs
+  # is resolved below: "<podspec_dir>/../../vendor" in the monorepo, and the copy
+  # dropped into "<podspec_dir>/cpp/highlight" by prepare-npm-publish.sh when
+  # published.
+  def self.manifest_path(podspec_dir)
+    [
+      File.join(podspec_dir, '../../vendor/grammar-versions.json'),
+      File.join(podspec_dir, 'cpp/highlight/grammar-versions.json'),
+    ].find { |p| File.exist?(p) }
+  end
+
+  # The default language set: every grammar flagged default:true in the manifest.
+  def self.default_languages(podspec_dir)
+    manifest = manifest_path(podspec_dir)
+    raise '[code-highlight] grammar-versions.json not found; cannot resolve the ' \
+          'default language set. Build from the monorepo or a published tarball.' unless manifest
+    grammars = JSON.parse(File.read(manifest))['grammars'] || {}
+    grammars.select { |_id, spec| spec['default'] }.keys
+  end
+
+  # podspec_dir is the directory of the including podspec; cpp is reached at
+  # "<podspec_dir>/cpp" (a symlink in the monorepo, real files when published).
+  def self.config(podspec_dir)
+    config = EnrichedMarkdownConfig.consumer_config
+    env_enable = ENV['ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT']
+
+    # Enable flag: package.json > ENV (deprecated) > default on. `explicit` tracks
+    # whether the consumer actively opted in (vs the implicit default), which decides
+    # the missing-asset behavior below.
+    if config.key?('enableCodeHighlight')
+      requested = config['enableCodeHighlight'] != false
+      explicit = requested
+      if env_enable
+        EnrichedMarkdownConfig.warn_once(:code_highlight_env, '[ReactNativeEnrichedMarkdown] DEPRECATED: ENV[\'ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT\'] ' \
+          'is ignored when "enriched-markdown".enableCodeHighlight is set in your package.json.')
+      end
+    elsif env_enable
+      EnrichedMarkdownConfig.warn_once(:code_highlight_env, '[ReactNativeEnrichedMarkdown] DEPRECATED: ENV[\'ENRICHED_MARKDOWN_ENABLE_CODE_HIGHLIGHT\'] ' \
+        'will be removed in a future version. Configure via "enriched-markdown".enableCodeHighlight in your package.json instead.')
+      requested = env_enable != '0'
+      explicit = requested
+    else
+      requested = true
+      explicit = false
+    end
+
+    return disabled unless requested
+
+    # The grammars/.stamp marker is written only after every grammar source is fully
+    # vendored at postinstall. If the consumer explicitly enabled highlighting but the
+    # grammars are absent (opted out of the download, or a partial/failed one), fail
+    # loud with the fix. If highlighting is merely on by default, degrade to the no-op
+    # stub so a missing download never breaks an otherwise-unconfigured build.
+    unless File.exist?(File.join(podspec_dir, 'cpp/highlight/vendor/grammars/.stamp'))
+      if explicit
+        raise '[ReactNativeEnrichedMarkdown] code highlighting is enabled but the tree-sitter ' \
+          'grammars are not installed. Reinstall to fetch them: `npm rebuild react-native-enriched-markdown-scaffold`. ' \
+          'To disable, set "enriched-markdown".enableCodeHighlight = false in your app package.json. ' \
+          'Troubleshooting: https://github.com/software-mansion/enriched-markdown/blob/main/docs/NATIVE_ASSETS.md'
+      end
+      return disabled
+    end
+
+    defaults = default_languages(podspec_dir)
+    # Languages: package.json > ENV (deprecated) > manifest defaults. An explicit empty
+    # array disables all languages (return disabled below); only the default/ENV paths
+    # fall back to the manifest set.
+    if config['codeHighlightLanguages'].is_a?(Array)
+      langs = config['codeHighlightLanguages'].map { |l| l.to_s.strip }.reject(&:empty?)
+    elsif (env_langs = ENV['ENRICHED_MARKDOWN_CODE_HIGHLIGHT_LANGUAGES']) && !env_langs.empty?
+      EnrichedMarkdownConfig.warn_once(:code_highlight_languages_env, '[ReactNativeEnrichedMarkdown] DEPRECATED: ENV[\'ENRICHED_MARKDOWN_CODE_HIGHLIGHT_LANGUAGES\'] ' \
+        'will be removed in a future version. Configure via "enriched-markdown".codeHighlightLanguages in your package.json instead.')
+      langs = env_langs.split(',').map(&:strip).reject(&:empty?)
+      langs = defaults.dup if langs.empty?
+    else
+      langs = defaults.dup
+    end
+    return disabled if langs.empty?
+
+    vendor = File.join(podspec_dir, 'cpp/highlight/vendor')
+    # A custom language set regenerates its registry into a per-app dir
+    # (generated-<app-slug>), never the committed default-set registry in vendor/generated.
+    # Keying by app (not by "generated-custom") means two apps in a hoisted monorepo with
+    # different custom sets each get their own registry instead of clobbering a single
+    # shared one -- which would leave the other app linking a mismatched grammar list.
+    custom = langs.sort != defaults.sort
+    generated_rel = custom ? "cpp/highlight/vendor/generated-#{EnrichedMarkdownConfig.consumer_app_slug}" : 'cpp/highlight/vendor/generated'
+    generated = File.join(podspec_dir, generated_rel)
+    ensure_registry(podspec_dir, vendor, generated, langs, custom)
+
+    sources = [
+      'cpp/highlight/vendor/tree-sitter/src/lib.c',
+      "#{generated_rel}/generated_registry.cpp",
+    ]
+    langs.each do |lang|
+      sources << "cpp/highlight/vendor/grammars/#{lang}/parser.c"
+      if File.exist?(File.join(vendor, "grammars/#{lang}/scanner.c"))
+        sources << "cpp/highlight/vendor/grammars/#{lang}/scanner.c"
+      end
+    end
+
+    {
+      enabled: true,
+      source_files: sources,
+      defines: ' ENRICHED_MARKDOWN_CODE_HIGHLIGHT=1',
+      header_paths: [
+        'cpp/highlight/vendor/tree-sitter/include',
+        generated_rel,
+      ],
+    }
+  end
+
+  def self.disabled
+    { enabled: false, source_files: [], defines: '', header_paths: [] }
+  end
+
+  # The committed default-set registry ships in-tree, so the default case needs no
+  # codegen. A custom set (or a missing default registry) regenerates into `generated`
+  # from the vendored .scm files.
+  def self.ensure_registry(podspec_dir, vendor, generated, langs, custom)
+    return if !custom && File.exist?(File.join(generated, 'generated_registry.cpp'))
+
+    script = [
+      File.join(podspec_dir, '../../vendor/gen-registry.mjs'),
+      File.join(podspec_dir, 'cpp/highlight/gen-registry.mjs'),
+    ].find { |p| File.exist?(p) }
+    raise '[code-highlight] ENRICHED_MARKDOWN_CODE_HIGHLIGHT_LANGUAGES is customized but ' \
+          'vendor/gen-registry.mjs was not found. Use the default set or build from the monorepo.' unless script
+
+    # Canonicalize before handing the path to node: in the monorepo the package is
+    # a workspace symlink, so the "../.." above resolves correctly for File.exist?
+    # (which follows the symlink physically) but node would normalize ".." lexically
+    # from the symlink location and miss the file. Android already does this via
+    # File#canonicalPath.
+    script = File.realpath(script)
+
+    ok = system('node', script, '--vendor-dir', vendor, '--languages', langs.join(','), '--out', generated)
+    raise '[code-highlight] gen-registry.mjs failed' unless ok
+  end
+end

package/cpp/highlight/gen-registry.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+// Build-time (and offline): emits the grammar registry for a selected language
+// subset from the in-tree vendored files. No network, reads only --vendor-dir.
+// Invoked by the Android CMake configure step and the iOS podspec, and by
+// vendor-grammars.mjs to refresh the committed default set.
+//
+//   node vendor/gen-registry.mjs --vendor-dir <dir> --languages a,b,c --out <dir>
+//
+// Writes <out>/generated_queries.h and <out>/generated_registry.cpp referencing
+// only the selected grammars, so the link step stays valid no matter how many
+// grammars are vendored. `; inherits:` directives are resolved by inlining the
+// parent grammar's highlights (parents come first, child overrides).
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+const LOG_PREFIX = '[react-native-enriched-markdown-scaffold]';
+const log = (message) => console.log(`${LOG_PREFIX} ${message}`);
+const warn = (message) => console.warn(`${LOG_PREFIX} ${message}`);
+const fail = (message) => {
+  console.error(`${LOG_PREFIX} ${message}`);
+  process.exit(1);
+};
+
+function parseArgs(argv) {
+  const args = { vendorDir: null, languages: [], out: null, manifest: path.join(here, 'grammar-versions.json') };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--vendor-dir') args.vendorDir = argv[++i];
+    else if (a === '--languages') args.languages = argv[++i].split(',').map((s) => s.trim()).filter(Boolean);
+    else if (a === '--out') args.out = argv[++i];
+    else if (a === '--manifest') args.manifest = argv[++i];
+  }
+  if (!args.vendorDir || !args.out) {
+    fail('usage: --vendor-dir <dir> --languages a,b --out <dir>');
+  }
+  return args;
+}
+
+function identifier(id) {
+  return id.replace(/[^A-Za-z0-9]/g, '_');
+}
+
+function grammarFunction(id, manifest) {
+  const spec = manifest.grammars?.[id];
+  return spec?.function ?? `tree_sitter_${identifier(id)}`;
+}
+
+function highlightsPath(vendorDir, id) {
+  return path.join(vendorDir, 'grammars', id, 'highlights.scm');
+}
+
+const INHERITS_RE = /^[ \t]*;+[ \t]*inherits[ \t]*:[ \t]*([^\n]+)$/m;
+
+// Reads a grammar's highlights.scm and inlines any `; inherits:` parents that
+// are also vendored. Cycle-guarded; a missing parent is skipped with a warning.
+function resolveHighlights(vendorDir, id, seen = new Set()) {
+  const file = highlightsPath(vendorDir, id);
+  if (!fs.existsSync(file)) {
+    fail(`missing vendored highlights for '${id}': ${file}`);
+  }
+  if (seen.has(id)) return '';
+  seen.add(id);
+
+  const raw = fs.readFileSync(file, 'utf8');
+  const match = raw.match(INHERITS_RE);
+  let inherited = '';
+  if (match) {
+    for (const parent of match[1].split(',').map((s) => s.trim()).filter(Boolean)) {
+      if (fs.existsSync(highlightsPath(vendorDir, parent))) {
+        inherited += resolveHighlights(vendorDir, parent, seen) + '\n';
+      } else {
+        warn(`${id} inherits '${parent}' which is not vendored; skipping inheritance`);
+      }
+    }
+  }
+  const body = raw.replace(INHERITS_RE, '');
+  return inherited + body;
+}
+
+function toCStringLines(text) {
+  const lines = text.split('\n');
+  return lines
+    .map((line, i) => {
+      // Escape backslashes, quotes, and every '?' so sequences like "??=" in a
+      // query never form a C trigraph.
+      const escaped = line.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\?/g, '\\?');
+      const newline = i < lines.length - 1 ? '\\n' : '';
+      return `    "${escaped}${newline}"`;
+    })
+    .join('\n');
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const manifest = JSON.parse(fs.readFileSync(args.manifest, 'utf8'));
+  fs.mkdirSync(args.out, { recursive: true });
+
+  const entries = args.languages.map((id) => ({
+    id,
+    ident: identifier(id),
+    fn: grammarFunction(id, manifest),
+    query: resolveHighlights(args.vendorDir, id),
+  }));
+
+  const queriesHeader =
+    '#pragma once\n' +
+    '// Generated by vendor/gen-registry.mjs. Do not edit.\n\n' +
+    'namespace Markdown {\n\n' +
+    entries
+      .map((e) => `static const char kHighlightsQuery_${e.ident}[] =\n${toCStringLines(e.query)};\n`)
+      .join('\n') +
+    '\n} // namespace Markdown\n';
+
+  const header =
+    '// Generated by vendor/gen-registry.mjs. Do not edit.\n\n' +
+    '#include "HighlightGrammars.hpp"\n' +
+    '#include "generated_queries.h"\n\n' +
+    '#include <cstring>\n\n';
+
+  let registryCpp;
+  if (entries.length === 0) {
+    registryCpp =
+      header +
+      'namespace Markdown {\n\n' +
+      'const GrammarEntry *findGrammar(const char * /*canonicalId*/) {\n  return nullptr;\n}\n\n' +
+      '} // namespace Markdown\n';
+  } else {
+    registryCpp =
+      header +
+      'extern "C" {\n' +
+      entries.map((e) => `const TSLanguage *${e.fn}(void);`).join('\n') +
+      '\n}\n\n' +
+      'namespace Markdown {\nnamespace {\n\n' +
+      'constexpr GrammarEntry kGrammars[] = {\n' +
+      entries.map((e) => `    {"${e.id}", ${e.fn}, kHighlightsQuery_${e.ident}},`).join('\n') +
+      '\n};\n\n' +
+      '} // namespace\n\n' +
+      'const GrammarEntry *findGrammar(const char *canonicalId) {\n' +
+      '  if (canonicalId == nullptr) {\n    return nullptr;\n  }\n' +
+      '  for (const GrammarEntry &entry : kGrammars) {\n' +
+      '    if (std::strcmp(entry.canonicalId, canonicalId) == 0) {\n      return &entry;\n    }\n  }\n' +
+      '  return nullptr;\n}\n\n' +
+      '} // namespace Markdown\n';
+  }
+
+  fs.writeFileSync(path.join(args.out, 'generated_queries.h'), queriesHeader);
+  fs.writeFileSync(path.join(args.out, 'generated_registry.cpp'), registryCpp);
+  log(`wrote ${entries.length} grammar(s) to ${args.out}`);
+}
+
+main();