@hyperscript-tools/i18n 2.7.1 → 2.8.0

package/README.md

@@ -21,16 +21,68 @@ HTML structure is preserved.
 
 ### Flags
 
-| Flag            | Description                                                                        |
-| --------------- | ---------------------------------------------------------------------------------- |
-| `--langs`, `-l` | Comma-separated target language codes (`ja,es,ko`).                                |
-| `--out`, `-o`   | Output directory. Defaults to `.`.                                                 |
-| `--from`, `-f`  | Source locale of the input. Defaults to `en`.                                      |
-| `--strict`      | Fail the run on any single attribute that can't be translated. Default is lenient. |
+| Flag            | Description                                                                                      |
+| --------------- | ------------------------------------------------------------------------------------------------ |
+| `--langs`, `-l` | Comma-separated target language codes (`ja,es,ko`).                                              |
+| `--out`, `-o`   | Output directory. Defaults to `.`.                                                               |
+| `--from`, `-f`  | Source locale of the input. Defaults to `en`.                                                    |
+| `--strict`      | Fail the run on any single attribute that can't be translated. Default is lenient.               |
+| `--check`       | Parse-check the English hyperscript on the real engine and exit 3 if any is invalid (see below). |
 
 Inputs may be individual files or directories — every `.html` in a directory
 is processed.
 
+## Canonical parse-check
+
+Every `_="..."` attribute this tool touches on the **English side** can be
+validated against the real [`hyperscript.org`](https://hyperscript.org) parser —
+the same engine the browser runs. This is checked for:
+
+- **input** when translating _from_ English (`--from en`, the default) — catches
+  an invalid canonical source before it ships in all 24 languages, and
+- **output** when a target language is `en` (foreign → English).
+
+Foreign-language _output_ is deliberately **not** round-trip-checked here: this
+package's grammar transformer is lossy in reverse, so a round-trip gate would be
+noise. Faithful foreign-output gating belongs to the semantic-engine transpiler
+(roadmap §5, "later").
+
+By default, invalid English prints a deduped warning and the run continues:
+
+```text
+sample.html: invalid hyperscript (English input -> ja): _="on click qqqq zzzz"
+  - Unexpected Token : qqqq
+```
+
+Pass `--check` to escalate to a build failure (exit code **3**) after all files
+are processed and written:
+
+```bash
+npx @hyperscript-tools/i18n translate src/page.html --langs ja,es --out dist/ --check
+```
+
+**Exit codes:** `0` success · `1` no inputs matched (or `--check` but the parser
+failed to load) · `2` usage error · `3` `--check` found invalid hyperscript.
+
+In the Eleventy plugin, use the `parseCheck` option (`'off' | 'warn' | 'error'`,
+default `'warn'`):
+
+```js
+eleventyConfig.addPlugin(hyperscriptI18n, { parseCheck: 'error' });
+```
+
+Programmatically:
+
+```ts
+import { validateHyperscript } from '@hyperscript-tools/i18n/validate';
+
+const errors = await validateHyperscript('on click toggle .active'); // [] = valid
+```
+
+> **Caveat:** the attribute scanner is a regex over `_="..."`, so hyperscript
+> inside HTML comments or `<script>` bodies is checked too. Warn-by-default keeps
+> that from breaking builds.
+
 ## Eleventy plugin
 
 ```js

package/dist/chunk-7ZOFDQYR.js

@@ -0,0 +1,57 @@
+// src/validate.ts
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+import path from "path";
+var cached;
+function loadValidator() {
+  if (!cached) {
+    cached = (async () => {
+      const require2 = createRequire(import.meta.url);
+      const iife = require2.resolve("hyperscript.org");
+      const esm = path.join(path.dirname(iife), "_hyperscript.esm.js");
+      const mod = await import(pathToFileURL(esm).href);
+      const hs = mod.default ?? mod;
+      if (typeof hs?.parse !== "function") {
+        throw new Error(
+          "Loaded hyperscript.org but it did not expose parse(); the package layout may have changed."
+        );
+      }
+      return (src) => {
+        try {
+          return (hs.parse(src)?.errors ?? []).map((e) => e.message.split("\n")[0]);
+        } catch (e) {
+          return ["threw: " + e.message.split("\n")[0]];
+        }
+      };
+    })();
+  }
+  return cached;
+}
+async function validateHyperscript(src) {
+  return (await loadValidator())(src);
+}
+function formatParseCheckReport(r) {
+  const code = r.code.length > 80 ? r.code.slice(0, 77) + "..." : r.code;
+  const where = r.stage === "input" ? `English input -> ${r.to}` : `English output <- ${r.from}`;
+  return [`invalid hyperscript (${where}): _="${code}"`, ...r.errors.map((e) => `  - ${e}`)].join(
+    "\n"
+  );
+}
+var warned = /* @__PURE__ */ new Set();
+function warnInvalidOnce(r) {
+  if (warned.has(r.code)) return false;
+  warned.add(r.code);
+  console.warn(`[hyperscript-i18n] ${formatParseCheckReport(r)}`);
+  return true;
+}
+function __resetParseCheckWarnings() {
+  warned.clear();
+}
+
+export {
+  loadValidator,
+  validateHyperscript,
+  formatParseCheckReport,
+  warnInvalidOnce,
+  __resetParseCheckWarnings
+};

package/dist/chunk-SYQOFAWY.js

@@ -0,0 +1,89 @@
+import {
+  formatParseCheckReport,
+  warnInvalidOnce
+} from "./chunk-7ZOFDQYR.js";
+
+// src/html.ts
+import { translate } from "@lokascript/i18n";
+var ATTR_PATTERNS = [
+  /(_\s*=\s*")([^"]+)(")/g,
+  /(_\s*=\s*')([^']+)(')/g,
+  /(_\s*=\s*`)([^`]+)(`)/g
+];
+function extractHyperscriptAttributes(html) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of ATTR_PATTERNS) {
+    for (const m of html.matchAll(pattern)) {
+      seen.add(m[2]);
+    }
+  }
+  return [...seen];
+}
+function checkHtmlInput(html, validate, to = "*") {
+  const reports = [];
+  for (const code of extractHyperscriptAttributes(html)) {
+    const errors = validate(code);
+    if (errors.length > 0) {
+      reports.push({ stage: "input", code, errors, from: "en", to });
+    }
+  }
+  return reports;
+}
+function dispatch(report, onInvalid) {
+  if (typeof onInvalid === "function") onInvalid(report);
+  else if (onInvalid === "error")
+    throw new Error(`[hyperscript-i18n] ${formatParseCheckReport(report)}`);
+  else warnInvalidOnce(report);
+}
+function translateHtml(html, to, options = {}) {
+  const from = options.from ?? "en";
+  const lenient = options.lenient ?? true;
+  const { validate } = options;
+  const onInvalid = options.onInvalid ?? "warn";
+  if (from === to) return html;
+  if (validate && options.checkInput !== false && from === "en") {
+    for (const report of checkHtmlInput(html, validate, to)) dispatch(report, onInvalid);
+  }
+  let out = html;
+  for (const pattern of ATTR_PATTERNS) {
+    out = out.replace(pattern, (_match, before, body, after) => {
+      let translated;
+      try {
+        translated = translate(body, from, to);
+      } catch (err) {
+        if (lenient) return `${before}${body}${after}`;
+        throw err;
+      }
+      if (validate && to === "en") {
+        const errors = validate(translated);
+        if (errors.length > 0) {
+          dispatch({ stage: "output", code: translated, errors, from, to }, onInvalid);
+        }
+      }
+      return `${before}${translated}${after}`;
+    });
+  }
+  return out;
+}
+function translateHtmlToManyLangs(html, langs, options = {}) {
+  const from = options.from ?? "en";
+  let perLang = options;
+  if (options.validate && options.checkInput !== false && from === "en") {
+    for (const report of checkHtmlInput(html, options.validate)) {
+      dispatch(report, options.onInvalid ?? "warn");
+    }
+    perLang = { ...options, checkInput: false };
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const lang of langs) {
+    out.set(lang, translateHtml(html, lang, perLang));
+  }
+  return out;
+}
+
+export {
+  extractHyperscriptAttributes,
+  checkHtmlInput,
+  translateHtml,
+  translateHtmlToManyLangs
+};

package/dist/cli.js

@@ -1,7 +1,12 @@
 #!/usr/bin/env node
 import {
+  checkHtmlInput,
   translateHtml
-} from "./chunk-XIEA5H7Z.js";
+} from "./chunk-SYQOFAWY.js";
+import {
+  formatParseCheckReport,
+  loadValidator
+} from "./chunk-7ZOFDQYR.js";
 
 // src/cli.ts
 import { mkdirSync, readFileSync, writeFileSync, existsSync, statSync, readdirSync } from "fs";
@@ -13,7 +18,8 @@ function parseArgs(argv) {
     langs: [],
     from: "en",
     out: ".",
-    strict: false
+    strict: false,
+    check: false
   };
   if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") return args;
   args.command = argv[0] === "translate" ? "translate" : "help";
@@ -28,6 +34,8 @@ function parseArgs(argv) {
       args.from = argv[++i] ?? "en";
     } else if (a === "--strict") {
       args.strict = true;
+    } else if (a === "--check") {
+      args.check = true;
     } else if (a.startsWith("-")) {
       throw new Error(`Unknown flag: ${a}`);
     } else {
@@ -59,7 +67,7 @@ function printHelp() {
   console.log(`hyperscript-i18n \u2014 translate _="..." attributes in HTML
 
 Usage:
-  hyperscript-i18n translate <input> [<input> ...] --langs <codes> --out <dir> [--from <code>] [--strict]
+  hyperscript-i18n translate <input> [<input> ...] --langs <codes> --out <dir> [--from <code>] [--strict] [--check]
 
 Options:
   --langs, -l   Comma-separated target language codes (e.g. ja,es,ko).
@@ -67,10 +75,20 @@ Options:
   --from, -f    Source locale of the input. Defaults to 'en'.
   --strict      Fail the run if any single attribute fails to translate.
                 Default is lenient: untranslatable snippets are left in place.
+  --check       Validate the ENGLISH hyperscript on the real hyperscript.org
+                parser (input when --from en; output when a target is en) and
+                exit 3 if any attribute is invalid. Without --check, invalid
+                attributes only print a warning.
 
 Output:
   For each input file foo.html and each lang, writes <out>/foo.<lang>.html.
 
+Exit codes:
+  0  success
+  1  no HTML inputs matched, or --check requested but the parser failed to load
+  2  usage error (bad flags / missing --langs / no inputs)
+  3  --check found invalid hyperscript
+
 Example:
   hyperscript-i18n translate src/patterns.html --langs ja,es,ko --out dist/
 `);
@@ -101,14 +119,43 @@ async function run(argv) {
     return 1;
   }
   mkdirSync(args.out, { recursive: true });
+  let validate;
+  try {
+    validate = await loadValidator();
+  } catch (err) {
+    const msg = err.message;
+    if (args.check) {
+      console.error(`--check requested but the canonical parser failed to load: ${msg}`);
+      return 1;
+    }
+    console.warn(`parse-check disabled (could not load hyperscript.org): ${msg}`);
+  }
+  const failures = [];
+  const printedCodes = /* @__PURE__ */ new Set();
+  const recorderFor = (file) => (report) => {
+    failures.push({ file, ...report });
+    if (!printedCodes.has(report.code)) {
+      printedCodes.add(report.code);
+      console.warn(`${file}: ${formatParseCheckReport(report)}`);
+    }
+  };
   let written = 0;
   for (const file of files) {
     const html = readFileSync(file, "utf8");
     const stem = basename(file, extname(file));
+    const onInvalid = recorderFor(file);
+    if (validate && args.from === "en") {
+      for (const report of checkHtmlInput(html, validate)) onInvalid(report);
+    }
     for (const lang of args.langs) {
       const translated = translateHtml(html, lang, {
         from: args.from,
-        lenient: !args.strict
+        lenient: !args.strict,
+        validate,
+        // still drives the OUTPUT check when lang === 'en'
+        checkInput: false,
+        // input already checked once above
+        onInvalid
       });
       const outPath = join(args.out, `${stem}.${lang}.html`);
       mkdirSync(dirname(outPath), { recursive: true });
@@ -119,6 +166,19 @@ async function run(argv) {
   console.log(
     `Wrote ${written} files (${files.length} input \xD7 ${args.langs.length} langs) to ${args.out}`
   );
+  if (args.check && failures.length > 0) {
+    const fileCount = new Set(failures.map((f) => f.file)).size;
+    console.error(
+      `
+Parse-check failed: ${failures.length} invalid hyperscript attribute(s) in ${fileCount} file(s):`
+    );
+    for (const f of failures) {
+      console.error(
+        `  ${f.file} [${f.stage}]: ${formatParseCheckReport(f).split("\n").join("\n  ")}`
+      );
+    }
+    return 3;
+  }
   return 0;
 }
 var isMain = import.meta.url === `file://${process.argv[1]}`;

package/dist/eleventy.d.ts

@@ -1,6 +1,7 @@
 import { LangCode } from './index.js';
 export { TranslateHtmlOptions, translateHtml, translateHtmlToManyLangs } from './index.js';
 import '@lokascript/i18n';
+import './validate.js';
 
 /**
  * Eleventy plugin entry: `@hyperscript-tools/i18n/eleventy`
@@ -22,6 +23,13 @@ import '@lokascript/i18n';
  *   export default function (eleventyConfig) {
  *     eleventyConfig.addPlugin(hyperscriptI18n);
  *   }
+ *
+ * The plugin is ASYNC: when `parseCheck` is on (the default), it awaits the
+ * canonical `hyperscript.org` parser before returning. Eleventy 3 awaits plugin
+ * callbacks passed to `addPlugin`, so the check is active before any template
+ * renders. All three filters are registered SYNCHRONOUSLY before that await, so
+ * an un-awaited caller (or Eleventy 2) still gets working filters — the check
+ * simply activates once the parser finishes loading.
  */
 
 interface EleventyPluginOptions {
@@ -29,6 +37,14 @@ interface EleventyPluginOptions {
     defaultFrom?: LangCode;
     /** Default lenient flag for HTML translation. Defaults to true. */
     lenient?: boolean;
+    /**
+     * Canonical parse-check for the ENGLISH side (input when source is 'en';
+     * output when a target is 'en'):
+     *   'off'   — no check
+     *   'warn'  — print a deduped warning for invalid English (default)
+     *   'error' — throw, failing the build
+     */
+    parseCheck?: 'off' | 'warn' | 'error';
     /** Override filter names (in case of collisions in your config). */
     filterNames?: {
         snippet?: string;
@@ -39,6 +55,6 @@ interface EleventyPluginOptions {
 interface EleventyConfig {
     addFilter(name: string, fn: (...args: unknown[]) => unknown): void;
 }
-declare function hyperscriptI18nPlugin(eleventyConfig: EleventyConfig, options?: EleventyPluginOptions): void;
+declare function hyperscriptI18nPlugin(eleventyConfig: EleventyConfig, options?: EleventyPluginOptions): Promise<void>;
 
 export { type EleventyPluginOptions, LangCode, hyperscriptI18nPlugin as default };

package/dist/eleventy.js

@@ -1,31 +1,52 @@
 import {
   translateHtml,
   translateHtmlToManyLangs
-} from "./chunk-XIEA5H7Z.js";
+} from "./chunk-SYQOFAWY.js";
+import {
+  formatParseCheckReport,
+  loadValidator,
+  warnInvalidOnce
+} from "./chunk-7ZOFDQYR.js";
 
 // src/eleventy.ts
 import { translate } from "@lokascript/i18n";
-function hyperscriptI18nPlugin(eleventyConfig, options = {}) {
+async function hyperscriptI18nPlugin(eleventyConfig, options = {}) {
   const defaultFrom = options.defaultFrom ?? "en";
   const lenient = options.lenient ?? true;
+  const parseCheck = options.parseCheck ?? "warn";
   const names = {
     snippet: options.filterNames?.snippet ?? "translateHs",
     snippetMany: options.filterNames?.snippetMany ?? "translateHsAll",
     html: options.filterNames?.html ?? "translateHsHtml"
   };
+  let validate;
+  const check = (code, stage, from, to) => {
+    if (!validate) return;
+    const errors = validate(code);
+    if (errors.length === 0) return;
+    const report = { stage, code, errors, from, to };
+    if (parseCheck === "error")
+      throw new Error(`[hyperscript-i18n] ${formatParseCheckReport(report)}`);
+    warnInvalidOnce(report);
+  };
   eleventyConfig.addFilter(names.snippet, (input, to, from) => {
     if (typeof input !== "string" || typeof to !== "string") return input;
     const source = typeof from === "string" ? from : defaultFrom;
     if (source === to) return input;
+    if (source === "en") check(input, "input", source, to);
+    let out;
     try {
-      return translate(input, source, to);
+      out = translate(input, source, to);
     } catch {
       return lenient ? input : "";
     }
+    if (to === "en") check(out, "output", source, to);
+    return out;
   });
   eleventyConfig.addFilter(names.snippetMany, (input, langs, from) => {
     if (typeof input !== "string" || !Array.isArray(langs)) return {};
     const source = typeof from === "string" ? from : defaultFrom;
+    if (source === "en") check(input, "input", source, "*");
     const out = {};
     for (const lang of langs) {
       if (typeof lang !== "string") continue;
@@ -37,7 +58,9 @@ function hyperscriptI18nPlugin(eleventyConfig, options = {}) {
         out[lang] = translate(input, source, lang);
       } catch {
         out[lang] = lenient ? input : "";
+        continue;
       }
+      if (lang === "en") check(out[lang], "output", source, "en");
     }
     return out;
   });
@@ -45,10 +68,28 @@ function hyperscriptI18nPlugin(eleventyConfig, options = {}) {
     if (typeof html !== "string" || typeof to !== "string") return html;
     const opts = {
       from: typeof from === "string" ? from : defaultFrom,
-      lenient
+      lenient,
+      validate: parseCheck === "off" ? void 0 : validate,
+      checkInput: true,
+      onInvalid: parseCheck === "error" ? "error" : "warn"
     };
     return translateHtml(html, to, opts);
   });
+  if (parseCheck !== "off") {
+    try {
+      validate = await loadValidator();
+    } catch (err) {
+      const msg = err.message;
+      if (parseCheck === "error") {
+        throw new Error(
+          `[hyperscript-i18n] parseCheck 'error' but the canonical parser failed to load: ${msg}`
+        );
+      }
+      console.warn(
+        `[hyperscript-i18n] parse-check disabled (could not load hyperscript.org): ${msg}`
+      );
+    }
+  }
 }
 export {
   hyperscriptI18nPlugin as default,

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { GrammarTransformer, toEnglish, toLocale, translate } from '@lokascript/i18n';
+import { CanonicalValidate, ParseCheckReport } from './validate.js';
+export { formatParseCheckReport, loadValidator, validateHyperscript } from './validate.js';
 
 /**
  * HTML attribute scanner + translator.
@@ -7,8 +9,16 @@ export { GrammarTransformer, toEnglish, toLocale, translate } from '@lokascript/
  * attributes, translates each from a source locale to a target locale, and
  * returns the rewritten HTML. The grammar transformer doesn't know about HTML;
  * this module is the glue.
+ *
+ * Optionally parse-checks the ENGLISH side against the real `hyperscript.org`
+ * engine (see ./validate): the input when `from === 'en'` and the output when
+ * `to === 'en'`. The check only runs when a `validate` function is supplied, so
+ * existing callers see no behaviour change.
  */
+
 type LangCode = string;
+/** What to do with an invalid-English report. */
+type OnInvalid = 'warn' | 'error' | ((report: ParseCheckReport) => void);
 interface TranslateHtmlOptions {
     /** Source locale of the input HTML's `_=` attributes. Defaults to 'en'. */
     from?: LangCode;
@@ -18,8 +28,30 @@ interface TranslateHtmlOptions {
      * whole page build.
      */
     lenient?: boolean;
+    /**
+     * Canonical validator (from `loadValidator()`). When absent, no parse-check
+     * runs and behaviour is unchanged.
+     */
+    validate?: CanonicalValidate;
+    /** What to do with an invalid-English report. Default 'warn' (deduped console.warn). */
+    onInvalid?: OnInvalid;
+    /**
+     * Set false when the caller already validated the English input (as
+     * `translateHtmlToManyLangs` and the CLI do). Default true.
+     */
+    checkInput?: boolean;
 }
+/**
+ * Every `_=` attribute body in `html` (double/single/backtick quoted), deduped,
+ * in document order.
+ */
+declare function extractHyperscriptAttributes(html: string): string[];
+/**
+ * Validate every English `_=` attribute body of `html`; returns a report for
+ * each invalid one (stage 'input').
+ */
+declare function checkHtmlInput(html: string, validate: CanonicalValidate, to?: LangCode): ParseCheckReport[];
 declare function translateHtml(html: string, to: LangCode, options?: TranslateHtmlOptions): string;
 declare function translateHtmlToManyLangs(html: string, langs: ReadonlyArray<LangCode>, options?: TranslateHtmlOptions): Map<LangCode, string>;
 
-export { type LangCode, type TranslateHtmlOptions, translateHtml, translateHtmlToManyLangs };
+export { CanonicalValidate, type LangCode, type OnInvalid, ParseCheckReport, type TranslateHtmlOptions, checkHtmlInput, extractHyperscriptAttributes, translateHtml, translateHtmlToManyLangs };

package/dist/index.js

@@ -1,15 +1,27 @@
 import {
+  checkHtmlInput,
+  extractHyperscriptAttributes,
   translateHtml,
   translateHtmlToManyLangs
-} from "./chunk-XIEA5H7Z.js";
+} from "./chunk-SYQOFAWY.js";
+import {
+  formatParseCheckReport,
+  loadValidator,
+  validateHyperscript
+} from "./chunk-7ZOFDQYR.js";
 
 // src/index.ts
 import { translate, toLocale, toEnglish, GrammarTransformer } from "@lokascript/i18n";
 export {
   GrammarTransformer,
+  checkHtmlInput,
+  extractHyperscriptAttributes,
+  formatParseCheckReport,
+  loadValidator,
   toEnglish,
   toLocale,
   translate,
   translateHtml,
-  translateHtmlToManyLangs
+  translateHtmlToManyLangs,
+  validateHyperscript
 };

package/dist/validate.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Canonical parse-check.
+ *
+ * Loads the REAL `hyperscript.org` engine headlessly (parse-only needs no DOM)
+ * and exposes a validate function that NEVER throws. The engine has two failure
+ * channels: `parse().errors` COLLECTS grammar errors, but the tokenizer THROWS
+ * on an unknown character (e.g. a leaked non-ASCII surface → `Unknown token: เ`)
+ * and the `js` command's `new Function` throws on invalid JavaScript. Both
+ * throws are folded into the returned array so callers have one contract —
+ * check `.length === 0`, never wrap in try/catch expecting invalidity to throw.
+ *
+ * Self-contained on purpose: node builtins + `hyperscript.org` only, no
+ * `@lokascript/*` or `@hyperfixi/*` imports, so the package stays extraction-ready.
+ */
+/** Parse `src` on the canonical engine; returns error messages (empty = valid). Never throws. */
+type CanonicalValidate = (src: string) => string[];
+interface ParseCheckReport {
+    /** 'input' = English source before translating; 'output' = English produced from a foreign source. */
+    stage: 'input' | 'output';
+    /** The invalid English hyperscript. */
+    code: string;
+    /** Canonical parser error messages (first line each). */
+    errors: string[];
+    /** Source locale of the translate call ('en' for stage 'input'). */
+    from: string;
+    /** Target locale ('en' for stage 'output'; '*' for an aggregated input check). */
+    to: string;
+}
+/**
+ * Load (once, module-cached) the canonical validator. Resolve `hyperscript.org`,
+ * then import the sibling prebuilt `_hyperscript.esm.js` by file URL. Rejects if
+ * the package cannot be loaded or does not expose `parse()`.
+ */
+declare function loadValidator(): Promise<CanonicalValidate>;
+/** Convenience: load (cached) and validate in one call. */
+declare function validateHyperscript(src: string): Promise<string[]>;
+/** Multi-line human-readable rendering of a report (head line + one `  - <error>` line each). */
+declare function formatParseCheckReport(r: ParseCheckReport): string;
+/** Default warn printer; dedupes by `r.code` per process. Returns true if it printed. */
+declare function warnInvalidOnce(r: ParseCheckReport): boolean;
+/** @internal test hook — clears the per-process warn-dedupe set. */
+declare function __resetParseCheckWarnings(): void;
+
+export { type CanonicalValidate, type ParseCheckReport, __resetParseCheckWarnings, formatParseCheckReport, loadValidator, validateHyperscript, warnInvalidOnce };

package/dist/validate.js

@@ -0,0 +1,14 @@
+import {
+  __resetParseCheckWarnings,
+  formatParseCheckReport,
+  loadValidator,
+  validateHyperscript,
+  warnInvalidOnce
+} from "./chunk-7ZOFDQYR.js";
+export {
+  __resetParseCheckWarnings,
+  formatParseCheckReport,
+  loadValidator,
+  validateHyperscript,
+  warnInvalidOnce
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperscript-tools/i18n",
-  "version": "2.7.1",
+  "version": "2.8.0",
   "description": "Build-time translation for hyperscript code samples — generate per-language HTML from a canonical English source",
   "type": "module",
   "main": "dist/index.js",
@@ -19,11 +19,15 @@
     },
     "./cli": {
       "default": "./dist/cli.js"
+    },
+    "./validate": {
+      "types": "./dist/validate.d.ts",
+      "import": "./dist/validate.js"
     }
   },
   "scripts": {
-    "build": "tsup src/index.ts src/cli.ts src/eleventy.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts src/cli.ts src/eleventy.ts --format esm --dts --watch",
+    "build": "tsup src/index.ts src/cli.ts src/eleventy.ts src/validate.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/cli.ts src/eleventy.ts src/validate.ts --format esm --dts --watch",
     "typecheck": "tsc --noEmit",
     "pretest": "../../scripts/ensure-fresh.sh ../i18n . && npm run build --silent",
     "test": "node --test test/*.test.mjs",
@@ -44,7 +48,8 @@
   "author": "HyperFixi Contributors",
   "license": "MIT",
   "dependencies": {
-    "@lokascript/i18n": "^2.7.1"
+    "@lokascript/i18n": "^2.8.0",
+    "hyperscript.org": "^0.9.93"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/dist/chunk-XIEA5H7Z.js

@@ -1,37 +0,0 @@
-// src/html.ts
-import { translate } from "@lokascript/i18n";
-var ATTR_PATTERNS = [
-  /(_\s*=\s*")([^"]+)(")/g,
-  /(_\s*=\s*')([^']+)(')/g,
-  /(_\s*=\s*`)([^`]+)(`)/g
-];
-function translateHtml(html, to, options = {}) {
-  const from = options.from ?? "en";
-  const lenient = options.lenient ?? true;
-  if (from === to) return html;
-  let out = html;
-  for (const pattern of ATTR_PATTERNS) {
-    out = out.replace(pattern, (_match, before, body, after) => {
-      try {
-        const translated = translate(body, from, to);
-        return `${before}${translated}${after}`;
-      } catch (err) {
-        if (lenient) return `${before}${body}${after}`;
-        throw err;
-      }
-    });
-  }
-  return out;
-}
-function translateHtmlToManyLangs(html, langs, options = {}) {
-  const out = /* @__PURE__ */ new Map();
-  for (const lang of langs) {
-    out.set(lang, translateHtml(html, lang, options));
-  }
-  return out;
-}
-
-export {
-  translateHtml,
-  translateHtmlToManyLangs
-};