@lokascript/htmx-adapter 3.0.0 → 3.1.0

package/dist/index.d.ts

@@ -86,11 +86,13 @@ declare function resetRegistry(): void;
  * allows):
  *
  * - **The authored attribute is never removed or rewritten** — devtools
- *   keeps showing what the author wrote. The one exception is an
- *   author-written canonical `hx-trigger` whose *value* uses localized
- *   event names (`hx-trigger="clic"`): there is no separate canonical
- *   target to write to, so the value is translated in place (idempotent —
- *   the maps are localized → canonical, so a second pass is a no-op).
+ *   keeps showing what the author wrote. Two documented exceptions:
+ *   an author-written canonical `hx-trigger` whose *value* uses localized
+ *   event names (`hx-trigger="clic"`) has no separate canonical target,
+ *   so the value is translated in place (idempotent — the maps are
+ *   localized → canonical, so a second pass is a no-op); and in executor
+ *   mode a canonical-named `hx-on:*` attribute may be removed by the
+ *   claim when no htmx hook exists to cancel htmx's binding (hx-on.ts).
  * - **An existing canonical attribute always wins.** If the element
  *   already has `hx-get`, a localized `hx-obtener` never overwrites it.
  * - **No vocab, no work.** With no languages registered every function
@@ -101,17 +103,40 @@ declare function resetRegistry(): void;
  * convention: Spanish writes `hx-obtener`, not `xx-obtener`), so the
  * prefix doubles as the discovery anchor.
  */
+/**
+ * Byte-mirror of htmx v4's `HCON.split` top-level-comma regex (vendored
+ * 4.0.0, `HCON.split`; pinned against the vendored file by
+ * test/vendor-mirror.test.ts). Spec boundaries must match core's grammar:
+ * commas inside `[filters]`, `(calls)`, and quoted strings — e.g.
+ * `from:".a, .b"` — are NOT separators.
+ *
+ * On htmx 4.0.0 the extension's `init(internalAPI)` swaps in htmx's own
+ * `HCON.split` (see setTriggerSpecSplitter), so the mirror is the
+ * fallback for v2 and for pages where the extension is not registered.
+ */
+declare const TOP_LEVEL_COMMA_RE: RegExp;
+type TriggerSpecSplitter = (value: string) => string[];
+/**
+ * Use htmx's own top-level splitter (`internalAPI.HCON.split` on 4.0.0)
+ * instead of the mirror. Pass `null` to restore the mirror.
+ */
+declare function setTriggerSpecSplitter(fn: TriggerSpecSplitter | null): void;
 /**
  * Translate localized event names inside an `hx-trigger` value.
  *
  * hx-trigger grammar: comma-separated specs, each `eventName[filter]
  * modifier…`. Only the leading event token of each spec is translated
- * (preserving an attached `[...]` filter); modifiers like `delay:500ms`,
- * `from:body`, `once` are language-invariant and left alone. Unknown
- * tokens pass through untouched, which also makes translation idempotent
- * (the maps are localized → canonical only).
+ * (an attached `[...]` filter, all modifiers like `delay:500ms` /
+ * `from:body` / `once`, and the authored spacing stay byte-identical —
+ * the split removes exactly the commas the join restores, so an
+ * all-canonical value comes back verbatim). Unknown tokens pass
+ * through untouched, which also makes translation idempotent (the maps
+ * are localized → canonical only). Only the map's OWN keys translate:
+ * `constructor` is not an event.
  */
 declare function translateTriggerValue(value: string, events: Record<string, string>): string;
+/** True when `name` on `elt` was written by canonicalization, not authored. */
+declare function wasCreatedByAdapter(elt: Element, name: string): boolean;
 /**
  * Canonicalize one element's localized htmx attributes in place.
  * Returns true if any attribute was added or updated.
@@ -131,18 +156,25 @@ declare function canonicalizeTree(root: Element | Document | DocumentFragment |
  * Primary target is **htmx v4**, whose extensions register via
  * `htmx.registerExtension(name, ext)` and hook lifecycle events through
  * underscore-named methods (event name with `:` → `_`), each receiving
- * `(elt, detail)`. Verified against htmx 4.0.0-beta5 (see
+ * `(elt, detail)`. Verified against htmx 4.0.0 (see
  * test/browser/vendor/README.md): `process(root)` fires
  * `htmx:before:process` on the processed root — `document.body`
  * initially, each swapped-in subtree afterwards — BEFORE any element
  * init or hx-on binding, so canonicalizing in `htmx_before_process`
  * covers everything htmx will read. `htmx_before_process_node` is kept
  * as a defensive alias for other v4 prereleases that used per-node
- * naming; an unmatched key is inert.
+ * naming; an unmatched key is inert. The cancelable
+ * `htmx_before_on_init` hook (fires per hx-on-carrying node, after
+ * before:process; documented as cancelable in htmx 4.0.0's `htmx.d.ts`)
+ * lets executor mode keep claimed `hx-on:*` attributes in the DOM
+ * instead of removing them — see createExtension.
  *
  * A v2 fallback (`htmx.defineExtension` + `onEvent('htmx:beforeProcessNode')`)
  * is included because the localized attribute names are version-agnostic
- * data — but v2 support is best-effort, not a tested target.
+ * data — but v2 support is best-effort, not a tested target. Measured on
+ * 2.0.10: `processNode` binds `hx-on` (`processHxOnWildcard`) BEFORE it
+ * fires `htmx:beforeProcessNode` per node, so v2 has no pre-bind seam and
+ * executor-mode claims keep removing canonical `hx-on:*` attrs there.
  *
  * The extension hook alone is not enough for the *initial* page: script
  * order decides whether our sweep beats htmx's own DOMContentLoaded scan.
@@ -154,25 +186,69 @@ declare function canonicalizeTree(root: Element | Document | DocumentFragment |
 declare const EXTENSION_NAME = "lokascript-i18n";
 /** Minimal shape of the htmx global we interact with. */
 interface HtmxLike {
-    /** htmx v4 registration entry point. */
-    registerExtension?(name: string, extension: object): void;
+    /**
+     * htmx v4 registration entry point. Returns `false` when the name is
+     * rejected — `htmx.config.extensions` is a non-empty allowlist that
+     * omits it, or it was already registered. (`htmx.d.ts` types the
+     * return as `void`; the runtime, verified on 4.0.0, returns `false`.)
+     */
+    registerExtension?(name: string, extension: object): boolean | void;
     /** htmx v1/v2 registration entry point. */
     defineExtension?(name: string, extension: object): void;
+    /** htmx v4 config — the parts that decide which hx-on spellings it binds. */
+    config?: {
+        /** Alternate attribute prefix (`data-hx-` by default; `''` disables it). */
+        prefix?: string;
+        /** Separator between `hx-on` and the event name (`:` by default). */
+        metaCharacter?: string;
+    };
 }
 /**
  * Build the extension object. v4 hooks and the v2 `onEvent` callback are
- * both present — each API only reads the members it knows about.
+ * both present — each API only reads the members it knows about. Pass
+ * the htmx instance so the v4 hook can read `config.prefix` /
+ * `config.metaCharacter` (defaults are assumed otherwise).
+ *
+ * `init(internalAPI)` (v4 only) takes exactly one thing from the API:
+ * `HCON.split`, htmx's own top-level trigger-spec splitter, which
+ * replaces the regex mirror in canonicalize.ts for the lifetime of the
+ * page. The rest of the 4.0.0 surface — `attributeValue`,
+ * `parseTriggerSpecs`, `getAttributeObject`, `insertContent`, `morph`,
+ * `initSecurity`, `onTrigger`, `htmxProp`, `triggerHtmxEvent`,
+ * `executeJavaScript` — was evaluated and not used: `parseTriggerSpecs`
+ * is parse-only (no serializer, so translating through it would mean a
+ * hand-written spec serializer); `attributeValue`'s inheritance-aware
+ * reads buy nothing for a sweep that visits every element anyway; and
+ * `htmxProp(node).onInitialized = true` WOULD keep htmx's binder off a
+ * node, but couples to a private flag where `htmx:before:on:init` is a
+ * typed, documented, cancelable event — the hook below uses that.
  */
-declare function createExtension(): object;
+declare function createExtension(htmx?: HtmxLike | null): object;
 /**
  * Register the extension with an htmx global. Returns which API accepted
- * it (`'v4'` / `'v2'`) or `null` if the object exposes neither.
+ * it (`'v4'` / `'v2'`) or `null` if the object exposes neither, or if
+ * v4 rejected the registration.
+ *
+ * Only an ACCEPTED v4 registration turns claim-time neutralization off:
+ * that is the one runtime whose per-node `htmx:before:on:init` hook can
+ * keep htmx off a preserved `hx-on:*` attribute. Everything else keeps
+ * the hook-independent removal guard.
  */
 declare function registerWith(htmx: HtmxLike | undefined | null): 'v4' | 'v2' | null;
 /**
- * Sweep the whole document now (if parsed) or on DOMContentLoaded, and
- * re-sweep whenever a vocab module registers after the initial sweep
- * (e.g. a vocab <script> below htmx, or dynamic registration).
+ * Sweep the whole document once the DOM is parsed, and re-sweep whenever
+ * a vocab module registers or the body executor changes after that
+ * (e.g. a vocab <script> below htmx, a lazily loaded _hyperscript, or
+ * dynamic registration).
+ *
+ * "Parsed" means DOMContentLoaded has FIRED (or `readyState` is already
+ * `'complete'`) — not merely `readyState !== 'loading'`. During
+ * DOMContentLoaded dispatch `readyState` is already `'interactive'`, and
+ * a `defer`/module adapter runs at `'interactive'` before htmx exists;
+ * sweeping then would claim in the default remove mode before
+ * `registerWith` had a chance to turn neutralization off. A `load`
+ * listener covers a script injected after DOMContentLoaded but before
+ * `'complete'` (DOMContentLoaded will not fire again for it).
  *
  * Returns a cleanup function (mainly for tests).
  */
@@ -253,11 +329,21 @@ declare function installResolverMode(htmx: ResolverConfigurableHtmx): () => void
  * - Localized-named attrs (`hx-en:clic`) stay verbatim in the DOM — htmx
  *   never recognized them anyway — and NO canonical `hx-on:*` sibling is
  *   created.
- * - Canonical-named attrs (`hx-on:click`) are REMOVED after claiming.
- *   This is the one place the adapter deletes an authored attribute: if
- *   it stayed, htmx would eval the hyperscript body as JS — a console
- *   error plus a double-execution attempt on every fire. Documented as
- *   the executor-mode exception in the README.
+ * - Canonical-named attrs (`hx-on:click`) must be kept away from htmx's
+ *   own binder: if htmx bound them, it would eval the hyperscript body
+ *   as JS — a console error plus a double-execution attempt on every
+ *   fire. A claim RECORDS the attribute (name + body) on the element;
+ *   what keeps htmx off it is decided by whoever owns the runtime:
+ *   - htmx v4, extension accepted: the extension's cancelable
+ *     `htmx:before:on:init` hook consults the record per node and
+ *     cancels htmx's binding — the authored attribute stays in the DOM
+ *     (see extension.ts). `registerWith` turns claim-time removal OFF
+ *     only after the registration actually succeeded.
+ *   - everywhere else (htmx v2, a rejected v4 registration, no htmx):
+ *     `neutralizeOnClaim` is ON (the default) and the canonical-named
+ *     attribute is removed at claim time — the only guard that does not
+ *     depend on a hook being installed, documented as the executor-mode
+ *     exception in the README.
  *
  * With no executor set (the default), none of this runs and bodies keep
  * upstream JS semantics — the behavior-preservation invariant.
@@ -266,10 +352,13 @@ declare function installResolverMode(htmx: ResolverConfigurableHtmx): () => void
  * loads after the initial sweep still applies. Both auto-detection
  * (`autoDetectBodyHooks`) and manual configuration are supported; the
  * executor is also re-read at fire time so replacing it takes effect on
- * live listeners.
+ * live listeners. The body is re-read on every re-claim, so
+ * `htmx.process(elt, true)` after editing the attribute runs the new body.
  */
 type BodyExecutor = (code: string, elt: Element, evt: Event) => unknown;
 type BodyTranslator = (body: string, lang: string) => string;
+declare function setNeutralizeOnClaim(enabled: boolean): void;
+declare function neutralizesOnClaim(): boolean;
 /** Configure the body executor. Setting/clearing it notifies subscribers. */
 declare function setBodyExecutor(fn: BodyExecutor | null): void;
 /** Configure the body translator (localized body → English hyperscript). */
@@ -278,16 +367,37 @@ declare function hasBodyExecutor(): boolean;
 declare function hasBodyTranslator(): boolean;
 /** Subscribe to executor changes. Returns an unsubscribe fn. */
 declare function onBodyHooksChanged(listener: () => void): () => void;
+/** True when the adapter has claimed at least one hx-on attribute on `elt`. */
+declare function isClaimed(elt: Element): boolean;
+/** Names of the attributes claimed on `elt` (canonical and localized). */
+declare function claimedAttrNames(elt: Element): Set<string>;
+/**
+ * Remove the claimed CANONICAL-named (`hx-on:*`) attributes from `elt`.
+ * The per-node fallback for runtimes that will bind the node anyway
+ * (v4 mixed nodes). Localized names are invisible to htmx and stay.
+ * Returns how many were removed.
+ */
+declare function removeClaimedCanonicalAttrs(elt: Element): number;
+interface ClaimOptions {
+    /**
+     * The attribute was written by the adapter's own canonicalization (a
+     * no-executor sweep's `hx-on:*` copy of a localized attr), not by the
+     * author. Such a duplicate is always removed on claim.
+     */
+    adapterCreated?: boolean;
+}
 /**
- * Claim one hx-on-family attribute on an element: install the executor
- * listener and neutralize htmx's view of it. Returns true if the claim
- * happened now (false when no executor, already claimed, or malformed).
+ * Claim one hx-on-family attribute on an element: record it, install the
+ * executor listener, and — when claim-time neutralization is on — remove
+ * a canonical-named attribute so htmx never JS-evals it. Returns true if
+ * the element changed or a listener was installed now (false when no
+ * executor, already claimed for that event, or malformed).
  *
  * `lang` is the element's language at claim time — used for lazy body
  * translation. `events` is the language's event-name map (for the
  * listener's event name; the shorthand/unknown cases pass through).
  */
-declare function claimHxOnAttribute(elt: Element, attrName: string, lang: string, events: Record<string, string>): boolean;
+declare function claimHxOnAttribute(elt: Element, attrName: string, lang: string, events: Record<string, string>, options?: ClaimOptions): boolean;
 /**
  * Auto-detect body hooks from page globals — called by the browser entry
  * at load and again at DOMContentLoaded. Never overwrites hooks that
@@ -302,4 +412,4 @@ declare function autoDetectBodyHooks(win: object): void;
 /** Reset all body-hook state. Mainly for tests. */
 declare function resetBodyHooks(): void;
 
-export { type BodyExecutor, type BodyTranslator, EXTENSION_NAME, type HtmxLike, type HtmxVocab, type VocabPayload, additionalAttributeSelectors, attributeResolver, autoDetectBodyHooks, canonicalizeElement, canonicalizeTree, claimHxOnAttribute, createExtension, hasAnyVocab, hasBodyExecutor, hasBodyTranslator, installAutoSweep, installResolverMode, isLangRegistered, isResolverMode, langOf, normLang, onBodyHooksChanged, onVocabUpdate, register, registerWith, resetBodyHooks, resetRegistry, setBodyExecutor, setBodyTranslator, setResolverMode, translateTriggerValue, vocabFor };
+export { type BodyExecutor, type BodyTranslator, type ClaimOptions, EXTENSION_NAME, type HtmxLike, type HtmxVocab, TOP_LEVEL_COMMA_RE, type TriggerSpecSplitter, type VocabPayload, additionalAttributeSelectors, attributeResolver, autoDetectBodyHooks, canonicalizeElement, canonicalizeTree, claimHxOnAttribute, claimedAttrNames, createExtension, hasAnyVocab, hasBodyExecutor, hasBodyTranslator, installAutoSweep, installResolverMode, isClaimed, isLangRegistered, isResolverMode, langOf, neutralizesOnClaim, normLang, onBodyHooksChanged, onVocabUpdate, register, registerWith, removeClaimedCanonicalAttrs, resetBodyHooks, resetRegistry, setBodyExecutor, setBodyTranslator, setNeutralizeOnClaim, setResolverMode, setTriggerSpecSplitter, translateTriggerValue, vocabFor, wasCreatedByAdapter };

package/dist/index.js

@@ -57,10 +57,18 @@ function resetRegistry() {
 }
 
 // src/hx-on.ts
+var hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
 var executor = null;
 var translator = null;
 var hookChangeListeners = /* @__PURE__ */ new Set();
 var claimed = /* @__PURE__ */ new WeakMap();
+var neutralizeOnClaim = true;
+function setNeutralizeOnClaim(enabled) {
+  neutralizeOnClaim = enabled;
+}
+function neutralizesOnClaim() {
+  return neutralizeOnClaim;
+}
 function setBodyExecutor(fn) {
   executor = fn;
   for (const listener of hookChangeListeners) listener();
@@ -80,44 +88,76 @@ function onBodyHooksChanged(listener) {
     hookChangeListeners.delete(listener);
   };
 }
+function isClaimed(elt) {
+  return (claimed.get(elt)?.size ?? 0) > 0;
+}
+function claimedAttrNames(elt) {
+  const names = /* @__PURE__ */ new Set();
+  const claims = claimed.get(elt);
+  if (claims) for (const c of claims.values()) names.add(c.attrName);
+  return names;
+}
+function removeClaimedCanonicalAttrs(elt) {
+  let n = 0;
+  for (const name of claimedAttrNames(elt)) {
+    if (name.startsWith("hx-on:") && elt.hasAttribute(name)) {
+      elt.removeAttribute(name);
+      n++;
+    }
+  }
+  return n;
+}
 function eventNameForSuffix(rawSuffix, events) {
   if (rawSuffix.startsWith(":")) return `htmx${rawSuffix}`;
-  return events[rawSuffix] ?? rawSuffix;
+  return hasOwn(events, rawSuffix) ? events[rawSuffix] : rawSuffix;
 }
-function claimHxOnAttribute(elt, attrName, lang, events) {
+function claimHxOnAttribute(elt, attrName, lang, events, options = {}) {
   if (!executor) return false;
   const colon = attrName.indexOf(":");
   if (colon <= 0) return false;
   const eventName = eventNameForSuffix(attrName.slice(colon + 1), events);
-  const already = claimed.get(elt);
-  if (already?.has(eventName)) {
-    if (attrName.startsWith("hx-on:") && elt.hasAttribute(attrName)) {
+  const canonical = attrName.startsWith("hx-on:");
+  const body = elt.getAttribute(attrName) ?? "";
+  let claims = claimed.get(elt);
+  const existing = claims?.get(eventName);
+  if (existing) {
+    if (existing.attrName === attrName) {
+      if (existing.body !== body) {
+        existing.body = body;
+        existing.translated = null;
+      }
+      if (canonical && neutralizeOnClaim && elt.hasAttribute(attrName)) {
+        elt.removeAttribute(attrName);
+        return true;
+      }
+      return false;
+    }
+    if (canonical && (options.adapterCreated || neutralizeOnClaim) && elt.hasAttribute(attrName)) {
       elt.removeAttribute(attrName);
       return true;
     }
     return false;
   }
-  const body = elt.getAttribute(attrName) ?? "";
-  let translatedBody = null;
+  const claim = { attrName, lang, body, translated: null };
   elt.addEventListener(eventName, (evt) => {
     if (!executor) return;
-    if (translatedBody === null) {
-      translatedBody = lang !== "en" && translator ? translator(body, lang) : body;
+    if (claim.translated === null) {
+      claim.translated = claim.lang !== "en" && translator ? translator(claim.body, claim.lang) : claim.body;
     }
     try {
-      executor(translatedBody, elt, evt);
+      executor(claim.translated, elt, evt);
     } catch (err) {
       if (typeof console !== "undefined") {
         console.error(`[htmx-i18n] hx-on body execution failed (${attrName} \u2192 ${eventName})`, err);
       }
     }
   });
-  if (attrName.startsWith("hx-on:")) elt.removeAttribute(attrName);
-  if (already) {
-    already.add(eventName);
-  } else {
-    claimed.set(elt, /* @__PURE__ */ new Set([eventName]));
+  if (!claims) {
+    claims = /* @__PURE__ */ new Map();
+    claimed.set(elt, claims);
   }
+  claims.set(eventName, claim);
+  if (canonical && neutralizeOnClaim) elt.removeAttribute(attrName);
   return true;
 }
 function autoDetectBodyHooks(win) {
@@ -138,6 +178,7 @@ function resetBodyHooks() {
   translator = null;
   hookChangeListeners.clear();
   claimed = /* @__PURE__ */ new WeakMap();
+  neutralizeOnClaim = true;
 }
 
 // src/resolver.ts
@@ -189,19 +230,36 @@ function installResolverMode(htmx) {
 }
 
 // src/canonicalize.ts
+var hasOwn2 = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
 var NS_RE = /^(?:hx|sse|ws)-/;
+var TOP_LEVEL_COMMA_RE = /,(?![^\[]*\])(?![^(]*\))(?![^<]*\/>)(?=(?:[^"']|"[^"]*"|'[^']*')*$)/;
+var mirrorSplit = (value) => value.split(TOP_LEVEL_COMMA_RE);
+var splitSpecs = mirrorSplit;
+function setTriggerSpecSplitter(fn) {
+  splitSpecs = fn ?? mirrorSplit;
+}
+function isTriggerAttr(name) {
+  return name === "hx-trigger" || name.startsWith("hx-trigger:");
+}
 function translateTriggerValue(value, events) {
-  return value.split(",").map((spec) => {
-    const trimmed = spec.trim();
-    if (!trimmed) return trimmed;
-    const parts = trimmed.split(/\s+/);
-    const m = parts[0].match(/^([^[\s]+)(\[.*)?$/);
-    if (m) {
-      const translated = events[m[1]];
-      if (translated) parts[0] = translated + (m[2] ?? "");
-    }
-    return parts.join(" ");
-  }).join(", ");
+  return splitSpecs(value).map(
+    (spec) => spec.replace(
+      /^(\s*)([^[\s]+)/,
+      (whole, ws, evt) => hasOwn2(events, evt) ? ws + events[evt] : whole
+    )
+  ).join(",");
+}
+var created = /* @__PURE__ */ new WeakMap();
+function markCreated(elt, name) {
+  let names = created.get(elt);
+  if (!names) {
+    names = /* @__PURE__ */ new Set();
+    created.set(elt, names);
+  }
+  names.add(name);
+}
+function wasCreatedByAdapter(elt, name) {
+  return created.get(elt)?.has(name) ?? false;
 }
 function canonicalizeElement(elt) {
   if (!elt.attributes || elt.attributes.length === 0) return false;
@@ -223,23 +281,43 @@ function canonicalizeElement(elt) {
   }
   const attrs = vocab?.attrs ?? {};
   const events = vocab?.events ?? {};
+  let hasEvents = false;
+  for (const _ in events) {
+    hasEvents = true;
+    break;
+  }
   let changed = false;
   for (const attr of Array.from(elt.attributes)) {
     const name = attr.name;
     if (!NS_RE.test(name)) continue;
     if (executorMode && name.startsWith("hx-on:")) {
-      if (claimHxOnAttribute(elt, name, lang, events)) changed = true;
+      if (claimHxOnAttribute(elt, name, lang, events, {
+        adapterCreated: wasCreatedByAdapter(elt, name)
+      })) {
+        changed = true;
+      }
+      continue;
+    }
+    if (isTriggerAttr(name)) {
+      if (hasEvents) {
+        const translated = translateTriggerValue(attr.value, events);
+        if (translated !== attr.value) {
+          elt.setAttribute(name, translated);
+          changed = true;
+        }
+      }
       continue;
     }
-    let canonical = attrs[name];
+    let canonical = hasOwn2(attrs, name) ? attrs[name] : void 0;
     let colonBase;
     if (!canonical) {
       const colon = name.indexOf(":");
       if (colon > 0) {
-        colonBase = attrs[name.slice(0, colon)];
+        const base = name.slice(0, colon);
+        colonBase = hasOwn2(attrs, base) ? attrs[base] : void 0;
         if (colonBase) {
           const suffix = name.slice(colon + 1);
-          canonical = `${colonBase}:${events[suffix] ?? suffix}`;
+          canonical = colonBase === "hx-on" ? `${colonBase}:${hasOwn2(events, suffix) ? events[suffix] : suffix}` : `${colonBase}:${suffix}`;
         }
       }
     }
@@ -250,18 +328,11 @@ function canonicalizeElement(elt) {
     }
     if (canonical === name || elt.hasAttribute(canonical)) continue;
     let value = attr.value;
-    if (canonical === "hx-trigger") value = translateTriggerValue(value, events);
+    if (isTriggerAttr(canonical)) value = translateTriggerValue(value, events);
     elt.setAttribute(canonical, value);
+    markCreated(elt, canonical);
     changed = true;
   }
-  const trigger = elt.getAttribute("hx-trigger");
-  if (trigger !== null && Object.keys(events).length > 0) {
-    const translated = translateTriggerValue(trigger, events);
-    if (translated !== trigger) {
-      elt.setAttribute("hx-trigger", translated);
-      changed = true;
-    }
-  }
   return changed;
 }
 function canonicalizeTree(root) {
@@ -280,9 +351,24 @@ function canonicalizeTree(root) {
 
 // src/extension.ts
 var EXTENSION_NAME = "lokascript-i18n";
-function createExtension() {
+function isHtmxBindableHxOn(name, prefixes, mc) {
+  for (const p of prefixes) {
+    if (name === p) return true;
+    if (name.startsWith(p) && name.charAt(p.length) === mc) return true;
+  }
+  return false;
+}
+function createExtension(htmx) {
+  const cfg = htmx?.config;
+  const prefix = cfg && "prefix" in cfg ? cfg.prefix ?? "" : "data-hx-";
+  const mc = cfg?.metaCharacter || ":";
+  const hxOnPrefixes = prefix ? ["hx-on", prefix + "on"] : ["hx-on"];
   return {
-    // htmx v4 (verified on 4.0.0-beta5): fires on each process() root
+    init(internalAPI) {
+      const split = internalAPI?.HCON?.split;
+      if (typeof split === "function") setTriggerSpecSplitter(split.bind(internalAPI.HCON));
+    },
+    // htmx v4 (verified on 4.0.0): fires on each process() root
     // before element init and hx-on binding.
     htmx_before_process(elt) {
       canonicalizeTree(elt);
@@ -291,6 +377,36 @@ function createExtension() {
     htmx_before_process_node(elt) {
       canonicalizeTree(elt);
     },
+    // htmx v4 (verified on 4.0.0): fires per node carrying an
+    // hx-on-family attribute, cancelable — returning false makes htmx
+    // skip JS-binding that node entirely. This is executor mode's
+    // zero-mutation double-execution guard, decided from what the sweep
+    // RECORDED on the node (not from whether an executor is set now):
+    //
+    // - nothing claimed on this node → htmx proceeds as usual;
+    // - every hx-on attribute htmx would bind here is claimed → cancel,
+    //   the authored attributes stay in the DOM;
+    // - the node also carries forms htmx must bind and the adapter never
+    //   claims (the legacy composite `hx-on="event -> code"`, the
+    //   `config.prefix` spelling, a custom meta character) → per-node
+    //   cancellation would kill those too, so fall back to removing the
+    //   claimed canonical attrs and let htmx bind the rest.
+    htmx_before_on_init(elt) {
+      const claimedNames = claimedAttrNames(elt);
+      if (claimedNames.size === 0) return void 0;
+      let unclaimedBindable = false;
+      for (const attr of Array.from(elt.attributes)) {
+        const name = attr.name;
+        if (claimedNames.has(name)) continue;
+        if (isHtmxBindableHxOn(name, hxOnPrefixes, mc)) {
+          unclaimedBindable = true;
+          break;
+        }
+      }
+      if (!unclaimedBindable) return false;
+      removeClaimedCanonicalAttrs(elt);
+      return void 0;
+    },
     // htmx v1/v2 fallback: single event dispatcher.
     onEvent(name, evt) {
       if (name !== "htmx:beforeProcessNode") return;
@@ -302,13 +418,23 @@ function createExtension() {
 }
 function registerWith(htmx) {
   if (!htmx) return null;
-  const ext = createExtension();
+  const ext = createExtension(htmx);
   if (typeof htmx.registerExtension === "function") {
-    htmx.registerExtension(EXTENSION_NAME, ext);
+    if (htmx.registerExtension(EXTENSION_NAME, ext) === false) {
+      if (typeof console !== "undefined") {
+        console.warn(
+          `[htmx-i18n] htmx.registerExtension("${EXTENSION_NAME}") returned false \u2014 the extension is not registered. If htmx.config.extensions (the <meta name="htmx-config"> allowlist) is set, add "${EXTENSION_NAME}" to it. Swapped-in content will not be canonicalized; executor-mode claims fall back to removing canonical hx-on:* attrs.`
+        );
+      }
+      setNeutralizeOnClaim(true);
+      return null;
+    }
+    setNeutralizeOnClaim(false);
     return "v4";
   }
   if (typeof htmx.defineExtension === "function") {
     htmx.defineExtension(EXTENSION_NAME, ext);
+    setNeutralizeOnClaim(true);
     return "v2";
   }
   return null;
@@ -317,54 +443,73 @@ function installAutoSweep(doc = document) {
   const sweep = () => {
     canonicalizeTree(doc.body ?? doc.documentElement);
   };
-  let removeDomListener = null;
-  if (doc.readyState === "loading") {
-    const onReady = () => sweep();
-    doc.addEventListener("DOMContentLoaded", onReady, { once: true });
-    removeDomListener = () => doc.removeEventListener("DOMContentLoaded", onReady);
-  } else {
+  let ready = doc.readyState === "complete";
+  let removeReadyListeners = null;
+  if (ready) {
     sweep();
+  } else {
+    const onReady = () => {
+      if (ready) return;
+      ready = true;
+      removeReadyListeners?.();
+      sweep();
+    };
+    const win = doc.defaultView;
+    doc.addEventListener("DOMContentLoaded", onReady);
+    win?.addEventListener("load", onReady);
+    removeReadyListeners = () => {
+      doc.removeEventListener("DOMContentLoaded", onReady);
+      win?.removeEventListener("load", onReady);
+    };
   }
   const unsubscribeVocab = onVocabUpdate(() => {
-    if (doc.readyState !== "loading") sweep();
+    if (ready) sweep();
   });
   const unsubscribeBodyHooks = onBodyHooksChanged(() => {
-    if (doc.readyState !== "loading") sweep();
+    if (ready) sweep();
   });
   return () => {
-    removeDomListener?.();
+    removeReadyListeners?.();
     unsubscribeVocab();
     unsubscribeBodyHooks();
   };
 }
 export {
   EXTENSION_NAME,
+  TOP_LEVEL_COMMA_RE,
   additionalAttributeSelectors,
   attributeResolver,
   autoDetectBodyHooks,
   canonicalizeElement,
   canonicalizeTree,
   claimHxOnAttribute,
+  claimedAttrNames,
   createExtension,
   hasAnyVocab,
   hasBodyExecutor,
   hasBodyTranslator,
   installAutoSweep,
   installResolverMode,
+  isClaimed,
   isLangRegistered,
   isResolverMode,
   langOf,
+  neutralizesOnClaim,
   normLang,
   onBodyHooksChanged,
   onVocabUpdate,
   register,
   registerWith,
+  removeClaimedCanonicalAttrs,
   resetBodyHooks,
   resetRegistry,
   setBodyExecutor,
   setBodyTranslator,
+  setNeutralizeOnClaim,
   setResolverMode,
+  setTriggerSpecSplitter,
   translateTriggerValue,
-  vocabFor
+  vocabFor,
+  wasCreatedByAdapter
 };
 //# sourceMappingURL=index.js.map