local-operator-ui 0.34.45 → 0.34.47

package/out/main/index.js

@@ -50,8 +50,8 @@ const DAEMON_UNPAIRED = {
 };
 const BACKEND_STATUS_EVENT = "backend-status-changed";
 const BACKEND_RECONNECT_CHANNEL = "backend-reconnect";
-function isServerReachable(state) {
-  return state !== "detached" && state !== "wedged";
+function isServerReachable(state2) {
+  return state2 !== "detached" && state2 !== "wedged";
 }
 function relayNeedsRebuild(current, next) {
   return current.url !== next.url || current.token !== next.token;
@@ -1993,6 +1993,39 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
     accountId: zod.z.number().int().positive(),
     confirmed: zod.z.literal(true)
   }).strict(),
+  /*
+   * PHONE ACCESS SETUP (`features.tunnel_setup`, local-operator
+   * `docs/DESKTOP_API.md` "Explicit phone setup"). Three ops over ONE route,
+   * split by authority so a caller cannot mutate by accident:
+   *
+   * - `tunnel.setup.read`: GET, local metadata only. No upstream read, no token
+   *   refresh, never `verified` and never a quote - the cheap poll that rebuilds
+   *   the block after a window close or a lost response.
+   * - `tunnel.setup.plan`: POST `{action:"plan"}`, a FRESH account/quote/
+   *   preparation observation that changes nothing.
+   * - `tunnel.setup.run`: POST `{action:"run"}`, the only op that can write. The
+   *   backend REFUSES it without an explicit owner (422), so `credentialId` is
+   *   required here rather than defaulted: an account is never picked for the
+   *   user. `acceptMonthlyPrice` is a STRING, the exact fresh amount the user
+   *   saw, because the backend compares it to a fresh quote and a number would
+   *   round-trip through float formatting.
+   *
+   * ONLY the capability gates these. An older backend 404s the route, so the
+   * renderer asks `features.tunnel_setup` first and sends nothing without it.
+   */
+  zod.z.object({
+    op: zod.z.literal("tunnel.setup.read"),
+    credentialId: zod.z.number().int().positive().optional()
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("tunnel.setup.plan"),
+    credentialId: zod.z.number().int().positive().optional()
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("tunnel.setup.run"),
+    credentialId: zod.z.number().int().positive(),
+    acceptMonthlyPrice: zod.z.string().min(1).max(64).optional()
+  }).strict(),
   zod.z.object({ op: zod.z.literal("auth.start"), provider: id$1 }).strict(),
   zod.z.object({ op: zod.z.literal("auth.status"), id: id$1 }).strict(),
   zod.z.object({ op: zod.z.literal("auth.input"), id: id$1, promptId: id$1, value: secret }).strict(),
@@ -2573,6 +2606,44 @@ function desktopRefusalCodeForStatus(path2, status2) {
   if (status2 === 503) return DESKTOP_REFUSAL_CODE.planeClosed;
   return void 0;
 }
+zod.z.object({
+  step: zod.z.string(),
+  blocked_on: zod.z.string(),
+  configured: zod.z.boolean(),
+  ready: zod.z.boolean(),
+  verified: zod.z.boolean(),
+  url: zod.z.string().nullable(),
+  credential_id: zod.z.number().int().positive().nullable(),
+  identity_label: zod.z.string().nullable(),
+  credential_choices: zod.z.array(
+    zod.z.object({
+      id: zod.z.number().int().positive(),
+      identity_label: zod.z.string().nullable().optional()
+    }).passthrough()
+  ).default([]),
+  quote: zod.z.object({
+    monthly_price_usd: zod.z.string().nullable(),
+    positive_balance: zod.z.boolean(),
+    eligible: zod.z.boolean(),
+    account_valid: zod.z.boolean()
+  }).passthrough().nullable(),
+  receipts: zod.z.array(zod.z.object({ step: zod.z.string(), ok: zod.z.boolean(), text: zod.z.string() })).default([]),
+  remedy: zod.z.object({
+    kind: zod.z.string(),
+    text: zod.z.string(),
+    command: zod.z.string().nullable().optional(),
+    url: zod.z.string().nullable().optional()
+  }).nullable(),
+  source: zod.z.string(),
+  in_progress: zod.z.boolean().default(false),
+  progress: zod.z.array(zod.z.string()).default([]),
+  active_credential_id: zod.z.number().int().positive().nullable().default(null),
+  // Backend facts, separate from receipts: an emitted receipt does not prove
+  // an ambiguous activation succeeded or was rolled back.
+  billing_outcome: zod.z.string().optional(),
+  reservation_outcome: zod.z.string().optional(),
+  failure_stage: zod.z.string().optional()
+}).passthrough();
 const DESKTOP_MESSAGE_BYTE_BUDGET = 88e4;
 const DESKTOP_CONTROL_BYTE_BUDGET = 262144;
 const DESKTOP_SYSTEM_PROMPT_BYTE_BUDGET = 11e5;
@@ -2630,6 +2701,8 @@ function moveClientBoundMs(shape) {
 const PRESENCE_GESTURE_DEADLINE_MS = 18e4;
 const APPROVAL_APPROVE_DEADLINE_MS = PRESENCE_GESTURE_DEADLINE_MS + 15e3;
 const HUB_ITEM_MERGE_S = 120;
+const PHONE_SETUP_PLAN_DEADLINE_MS = 135e3;
+const PHONE_SETUP_RUN_DEADLINE_MS = 93e4;
 const HUB_ITEM_WRITE_DEADLINE_MS = (HUB_ITEM_MERGE_S + 30 + MOVE_CLIENT_MARGIN_S) * 1e3;
 const HUB_CHECK_DEADLINE_MS = 6e4;
 const HUB_APPLY_ALL_DEADLINE_MS = 5 * HUB_ITEM_WRITE_DEADLINE_MS;
@@ -2664,6 +2737,8 @@ function desktopRequestDeadlineMs(request) {
   }
   const op = typeof request === "string" ? request : request.op;
   if (op === "approvals.approve") return APPROVAL_APPROVE_DEADLINE_MS;
+  if (op === "tunnel.setup.run") return PHONE_SETUP_RUN_DEADLINE_MS;
+  if (op === "tunnel.setup.plan") return PHONE_SETUP_PLAN_DEADLINE_MS;
   const hub = hubWriteDeadlineMs(op);
   if (hub !== null) return hub;
   return LONG_READ_OPS.has(op) ? DESKTOP_LONG_READ_DEADLINE_MS : DESKTOP_CONTROL_DEADLINE_MS;
@@ -2728,6 +2803,10 @@ const READ_ONLY_OPS = /* @__PURE__ */ new Set([
   "subagents.transcript",
   "teams.get",
   "teams.list",
+  // The two phone-setup observations change nothing on the server; `tunnel.setup.run`
+  // is deliberately absent so a run that ran out of time gets the cautious sentence.
+  "tunnel.setup.plan",
+  "tunnel.setup.read",
   "usage.get"
 ]);
 const PANEL_READ_OPS = /* @__PURE__ */ new Set([
@@ -4023,6 +4102,30 @@ function desktopEndpoint(request) {
         path: `/v1/auth/accounts/${request.accountId}`,
         method: "DELETE"
       };
+    case "tunnel.setup.read":
+      return {
+        path: request.credentialId === void 0 ? "/v1/desktop/tunnel/setup" : `/v1/desktop/tunnel/setup?credential_id=${request.credentialId}`,
+        method: "GET"
+      };
+    case "tunnel.setup.plan":
+      return {
+        path: "/v1/desktop/tunnel/setup",
+        method: "POST",
+        body: {
+          action: "plan",
+          ...request.credentialId !== void 0 ? { credential_id: request.credentialId } : {}
+        }
+      };
+    case "tunnel.setup.run":
+      return {
+        path: "/v1/desktop/tunnel/setup",
+        method: "POST",
+        body: {
+          action: "run",
+          credential_id: request.credentialId,
+          ...request.acceptMonthlyPrice !== void 0 ? { accept_monthly_price: request.acceptMonthlyPrice } : {}
+        }
+      };
     case "auth.start":
       return {
         path: "/v1/auth/login",
@@ -4556,11 +4659,11 @@ function isZombie(pid) {
       const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
       return stat.slice(stat.lastIndexOf(")") + 1).trimStart().startsWith("Z");
     }
-    const state = node_child_process.execFileSync("/bin/ps", ["-o", "state=", "-p", String(pid)], {
+    const state2 = node_child_process.execFileSync("/bin/ps", ["-o", "state=", "-p", String(pid)], {
       encoding: "utf8",
       timeout: 1e3
     });
-    return state.trim().toUpperCase().startsWith("Z");
+    return state2.trim().toUpperCase().startsWith("Z");
   } catch {
     return false;
   }
@@ -4672,9 +4775,9 @@ async function probeIdentity(address, expectedInstanceId, options = {}) {
 }
 const VERSION_SEPARATOR = /[.+-]/;
 function compareVersions$1(a, b) {
-  const parse = (value) => value.split(VERSION_SEPARATOR).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
-  const left = parse(a);
-  const right = parse(b);
+  const parse2 = (value) => value.split(VERSION_SEPARATOR).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
+  const left = parse2(a);
+  const right = parse2(b);
   for (let i = 0; i < 3; i++) {
     if (left[i] !== right[i]) return left[i] - right[i];
   }
@@ -5858,13 +5961,13 @@ function clearLastInstallAttempt(dir) {
 }
 const VERSION_TRIPLE_REGEX = /^v?(\d+)\.(\d+)\.(\d+)/;
 function compareVersions(a, b) {
-  const parse = (value) => {
+  const parse2 = (value) => {
     const match = VERSION_TRIPLE_REGEX.exec(value.trim());
     if (!match) return null;
     return [Number(match[1]), Number(match[2]), Number(match[3])];
   };
-  const left = parse(a);
-  const right = parse(b);
+  const left = parse2(a);
+  const right = parse2(b);
   if (!left || !right) return null;
   for (let index = 0; index < 3; index++) {
     if (left[index] !== right[index])
@@ -9436,8 +9539,8 @@ function inspectManagedSelection(options) {
   return { kind: "ready", selection };
 }
 function readManagedSelection(options) {
-  const state = inspectManagedSelection(options);
-  return state.kind === "ready" ? state.selection : null;
+  const state2 = inspectManagedSelection(options);
+  return state2.kind === "ready" ? state2.selection : null;
 }
 async function managedSelectionReady(options) {
   return inspectManagedSelection(options).kind === "ready";
@@ -9648,10 +9751,10 @@ async function smokeEnvironment(venv, env) {
 }
 async function prepareManagedPython(options, install) {
   return locked(managedPythonRoot(options), async (held) => {
-    const state = inspectManagedSelection(options);
-    if (state.kind === "ready") return state.selection;
-    const superseded = state.kind === "missing" ? state.detail : null;
-    const published = state.kind === "missing" ? state.published : null;
+    const state2 = inspectManagedSelection(options);
+    if (state2.kind === "ready") return state2.selection;
+    const superseded = state2.kind === "missing" ? state2.detail : null;
+    const published = state2.kind === "missing" ? state2.published : null;
     return publishGeneration(
       options,
       install,
@@ -9725,16 +9828,16 @@ function managedSelectionSatisfies(options, target2, isNewer) {
 }
 async function updateManagedPython(options, install, decision) {
   return locked(managedPythonRoot(options), async (held) => {
-    const state = inspectManagedSelection(options);
-    const published = state.kind === "ready" ? state.selection : null;
+    const state2 = inspectManagedSelection(options);
+    const published = state2.kind === "ready" ? state2.selection : null;
     if (published && managedSelectionSatisfies(options, decision.target, decision.isNewer))
       return { selection: published, replaced: false, previous: null };
-    const previous = published ?? (state.kind === "missing" ? state.published : null);
+    const previous = published ?? (state2.kind === "missing" ? state2.published : null);
     const selection = await publishGeneration(
       options,
       install,
       previous,
-      state.kind === "missing" ? state.detail : null,
+      state2.kind === "missing" ? state2.detail : null,
       true,
       held
     );
@@ -14532,10 +14635,10 @@ ${error instanceof Error ? error.message : String(error ?? "")}`;
       if (ok) this.settleInstalled();
       return ok;
     }
-    const state = inspectManagedSelection(this.managedOptions());
-    if (state.kind === "missing")
+    const state2 = inspectManagedSelection(this.managedOptions());
+    if (state2.kind === "missing")
       logger.warn(
-        `Published backend environment is not usable and will be rebuilt: ${state.detail}`,
+        `Published backend environment is not usable and will be rebuilt: ${state2.detail}`,
         LogFileType.INSTALLER
       );
     this.ensurePreparationWindow(show);
@@ -15348,7 +15451,7 @@ class BrowserStateWriter {
   write() {
     try {
       const facts = this.facts();
-      const state = {
+      const state2 = {
         pid: process.pid,
         port: this.port,
         session_key: this.sessionKey,
@@ -15389,7 +15492,7 @@ class BrowserStateWriter {
         mode: STATE_DIR_MODE
       });
       const staged = `${this.path}.${process.pid}.tmp`;
-      fs.writeFileSync(staged, `${JSON.stringify(state, null, 2)}
+      fs.writeFileSync(staged, `${JSON.stringify(state2, null, 2)}
 `, {
         mode: STATE_FILE_MODE
       });
@@ -16148,13 +16251,13 @@ function requireCreateNode() {
   const defaultTagPrefix = "tag:yaml.org,2002:";
   function findTagObject(value, tagName, tags2) {
     if (tagName) {
-      const match = tags2.filter((t) => t.tag === tagName);
-      const tagObj = match.find((t) => !t.format) ?? match[0];
+      const match = tags2.filter((t2) => t2.tag === tagName);
+      const tagObj = match.find((t2) => !t2.format) ?? match[0];
       if (!tagObj)
         throw new Error(`Tag ${tagName} not found`);
       return tagObj;
     }
-    return tags2.find((t) => t.identify?.(value) && !t.format);
+    return tags2.find((t2) => t2.identify?.(value) && !t2.format);
   }
   function createNode$1(value, tagName, ctx) {
     if (identity2.isDocument(value))
@@ -16784,10 +16887,10 @@ ${indent}`);
     let res = _stringify(type2);
     if (res === null) {
       const { defaultKeyType, defaultStringType } = ctx.options;
-      const t = implicitKey && defaultKeyType || defaultStringType;
-      res = _stringify(t);
+      const t2 = implicitKey && defaultKeyType || defaultStringType;
+      res = _stringify(t2);
       if (res === null)
-        throw new Error(`Unsupported default string type ${t}`);
+        throw new Error(`Unsupported default string type ${t2}`);
     }
     return res;
   }
@@ -16845,24 +16948,24 @@ function requireStringify() {
   }
   function getTagObject(tags2, item) {
     if (item.tag) {
-      const match = tags2.filter((t) => t.tag === item.tag);
+      const match = tags2.filter((t2) => t2.tag === item.tag);
       if (match.length > 0)
-        return match.find((t) => t.format === item.format) ?? match[0];
+        return match.find((t2) => t2.format === item.format) ?? match[0];
     }
     let tagObj = void 0;
     let obj;
     if (identity2.isScalar(item)) {
       obj = item.value;
-      let match = tags2.filter((t) => t.identify?.(obj));
+      let match = tags2.filter((t2) => t2.identify?.(obj));
       if (match.length > 1) {
-        const testMatch = match.filter((t) => t.test);
+        const testMatch = match.filter((t2) => t2.test);
         if (testMatch.length > 0)
           match = testMatch;
       }
-      tagObj = match.find((t) => t.format === item.format) ?? match.find((t) => !t.format);
+      tagObj = match.find((t2) => t2.format === item.format) ?? match.find((t2) => !t2.format);
     } else {
       obj = item;
-      tagObj = tags2.find((t) => t.nodeClass && obj instanceof t.nodeClass);
+      tagObj = tags2.find((t2) => t2.nodeClass && obj instanceof t2.nodeClass);
     }
     if (!tagObj) {
       const name = obj?.constructor?.name ?? typeof obj;
@@ -19104,9 +19207,9 @@ function requireErrors() {
     let ci = col - 1;
     let lineStr = src.substring(lc.lineStarts[line - 1], lc.lineStarts[line]).replace(/[\n\r]+$/, "");
     if (ci >= 60 && lineStr.length > 80) {
-      const trimStart = Math.min(ci - 39, lineStr.length - 79);
-      lineStr = "…" + lineStr.substring(trimStart);
-      ci -= trimStart - 1;
+      const trimStart4 = Math.min(ci - 39, lineStr.length - 79);
+      lineStr = "…" + lineStr.substring(trimStart4);
+      ci -= trimStart4 - 1;
     }
     if (lineStr.length > 80)
       lineStr = lineStr.substring(0, 79) + "…";
@@ -19784,7 +19887,7 @@ function requireComposeCollection() {
     if (!tagToken || !tagName || tagName === "!" || tagName === YAMLMap2.YAMLMap.tagName && expType === "map" || tagName === YAMLSeq2.YAMLSeq.tagName && expType === "seq") {
       return resolveCollection(CN, ctx, token, onError, tagName);
     }
-    let tag = ctx.schema.tags.find((t) => t.tag === tagName && t.collection === expType);
+    let tag = ctx.schema.tags.find((t2) => t2.tag === tagName && t2.collection === expType);
     if (!tag) {
       const kt = ctx.schema.knownTags[tagName];
       if (kt && kt.collection === expType) {
@@ -21186,11 +21289,11 @@ function requireLexer() {
     hasChars(n) {
       return this.pos + n <= this.buffer.length;
     }
-    setNext(state) {
+    setNext(state2) {
       this.buffer = this.buffer.substring(this.pos);
       this.pos = 0;
       this.lineEndPos = null;
-      this.next = state;
+      this.next = state2;
       return null;
     }
     peek(n) {
@@ -21783,7 +21886,7 @@ function requireParser() {
       }
     }
   }
-  class Parser {
+  class Parser2 {
     /**
      * @param onNewLine - If defined, called separately with the start position of
      *   each new line (in `parse()`, including the start of input).
@@ -22556,7 +22659,7 @@ function requireParser() {
       }
     }
   }
-  parser.Parser = Parser;
+  parser.Parser = Parser2;
   return parser;
 }
 var publicApi = {};
@@ -22609,7 +22712,7 @@ function requirePublicApi() {
     }
     return doc;
   }
-  function parse(src, reviver, options) {
+  function parse2(src, reviver, options) {
     let _reviver = void 0;
     if (typeof reviver === "function") {
       _reviver = reviver;
@@ -22650,7 +22753,7 @@ function requirePublicApi() {
       return value.toString(options);
     return new Document2.Document(value, _replacer, options).toString(options);
   }
-  publicApi.parse = parse;
+  publicApi.parse = parse2;
   publicApi.parseAllDocuments = parseAllDocuments;
   publicApi.parseDocument = parseDocument;
   publicApi.stringify = stringify2;
@@ -23331,8 +23434,8 @@ function consoleCompletionHooks(deps) {
     };
   };
   const displayed = (surface) => {
-    const state = deps.host()?.state();
-    return state?.displayed_surface === surface;
+    const state2 = deps.host()?.state();
+    return state2?.displayed_surface === surface;
   };
   const completionFor = (surface, exitCode, key) => {
     const described = describe2(surface);
@@ -23906,8 +24009,8 @@ class ConsoleRegistry {
       restored: { user: 0, agent: 0 }
     };
     for (const entry of this.entries.values()) {
-      const state = !entry.record.live ? "restored" : !entry.record.running ? "exited" : entry.runtime === null ? "starting" : "running";
-      states[state][entry.record.origin] += 1;
+      const state2 = !entry.record.live ? "restored" : !entry.record.running ? "exited" : entry.runtime === null ? "starting" : "running";
+      states[state2][entry.record.origin] += 1;
     }
     return {
       generation: this.generation,
@@ -27540,12 +27643,12 @@ function newEntry(origin, displayAuthority2, requester, kind, now, sequence, com
     ...broad ? { broad } : {}
   };
 }
-function receiptFor(entry, state, now) {
+function receiptFor(entry, state2, now) {
   return {
     entryId: entry.entryId,
     origin: entry.origin,
     requester: entry.requester,
-    state,
+    state: state2,
     decidedAt: now,
     expiresAt: now + ACCESS_RESULT_TTL_MS
   };
@@ -27827,10 +27930,10 @@ class ApprovalStore {
     );
     return this.entryResponse(entry, "pending");
   }
-  entryResponse(entry, state) {
+  entryResponse(entry, state2) {
     return {
       origin: entry.origin,
-      state,
+      state: state2,
       entry_id: entry.entryId,
       authority: entry.displayAuthority,
       expires_at: entry.expiresAt,
@@ -27849,7 +27952,7 @@ class ApprovalStore {
       void 0,
       now
     );
-    const state = accessState(
+    const state2 = accessState(
       entry ? {
         origin: entry.origin,
         hostname: entry.displayAuthority,
@@ -27879,12 +27982,12 @@ class ApprovalStore {
       requester,
       now
     );
-    if (state === "none" && this.refusalReason(url) === "denied") {
+    if (state2 === "none" && this.refusalReason(url) === "denied") {
       return { origin: url.origin, state: "denied" };
     }
     return {
       origin: url.origin,
-      state,
+      state: state2,
       ...entry ? { entry_id: entry.entryId } : {}
     };
   }
@@ -28798,6 +28901,3401 @@ class CdpPool {
     for (const id2 of [...this.attachments.keys()]) await this.detach(id2);
   }
 }
+function memoize(fn, options) {
+  const cache = options && options.cache ? options.cache : cacheDefault;
+  const serializer = options && options.serializer ? options.serializer : serializerDefault;
+  return (options && options.strategy ? options.strategy : strategyDefault)(fn, {
+    cache,
+    serializer
+  });
+}
+function isPrimitive(value) {
+  return value == null || typeof value === "number" || typeof value === "boolean";
+}
+function monadic(fn, cache, serializer, arg) {
+  const cacheKey = isPrimitive(arg) ? arg : serializer(arg);
+  let computedValue = cache.get(cacheKey);
+  if (typeof computedValue === "undefined") {
+    computedValue = fn.call(this, arg);
+    cache.set(cacheKey, computedValue);
+  }
+  return computedValue;
+}
+function variadic(fn, cache, serializer) {
+  const args = Array.prototype.slice.call(arguments, 3);
+  const cacheKey = serializer(args);
+  let computedValue = cache.get(cacheKey);
+  if (typeof computedValue === "undefined") {
+    computedValue = fn.apply(this, args);
+    cache.set(cacheKey, computedValue);
+  }
+  return computedValue;
+}
+function assemble(fn, context, strategy, cache, serialize) {
+  return strategy.bind(context, fn, cache, serialize);
+}
+function strategyDefault(fn, options) {
+  const strategy = fn.length === 1 ? monadic : variadic;
+  return assemble(fn, this, strategy, options.cache.create(), options.serializer);
+}
+function strategyVariadic(fn, options) {
+  return assemble(fn, this, variadic, options.cache.create(), options.serializer);
+}
+const serializerDefault = function() {
+  return JSON.stringify(arguments);
+};
+var ObjectWithoutPrototypeCache = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ Object.create(null);
+  }
+  get(key) {
+    return this.cache[key];
+  }
+  set(key, value) {
+    this.cache[key] = value;
+  }
+};
+const cacheDefault = { create: function create() {
+  return new ObjectWithoutPrototypeCache();
+} };
+const strategies = {
+  variadic: strategyVariadic
+};
+const DATE_TIME_REGEX = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g;
+function parseDateTimeSkeleton(skeleton) {
+  const result = {};
+  skeleton.replace(DATE_TIME_REGEX, (match) => {
+    const len = match.length;
+    switch (match[0]) {
+      case "G":
+        result.era = len === 4 ? "long" : len === 5 ? "narrow" : "short";
+        break;
+      case "y":
+        result.year = len === 2 ? "2-digit" : "numeric";
+        break;
+      case "Y":
+      case "u":
+      case "U":
+      case "r":
+        throw new RangeError("`Y/u/U/r` (year) patterns are not supported, use `y` instead");
+      case "q":
+      case "Q":
+        throw new RangeError("`q/Q` (quarter) patterns are not supported");
+      case "M":
+      case "L":
+        result.month = [
+          "numeric",
+          "2-digit",
+          "short",
+          "long",
+          "narrow"
+        ][len - 1];
+        break;
+      case "w":
+      case "W":
+        throw new RangeError("`w/W` (week) patterns are not supported");
+      case "d":
+        result.day = ["numeric", "2-digit"][len - 1];
+        break;
+      case "D":
+      case "F":
+      case "g":
+        throw new RangeError("`D/F/g` (day) patterns are not supported, use `d` instead");
+      case "E":
+        result.weekday = len === 4 ? "long" : len === 5 ? "narrow" : "short";
+        break;
+      case "e":
+        if (len < 4) throw new RangeError("`e..eee` (weekday) patterns are not supported");
+        result.weekday = [
+          "short",
+          "long",
+          "narrow",
+          "short"
+        ][len - 3];
+        break;
+      case "c":
+        if (len < 4) throw new RangeError("`c..ccc` (weekday) patterns are not supported");
+        result.weekday = [
+          "short",
+          "long",
+          "narrow",
+          "short"
+        ][len - 3];
+        break;
+      case "a":
+        result.hour12 = true;
+        break;
+      case "b":
+      case "B":
+        throw new RangeError("`b/B` (period) patterns are not supported, use `a` instead");
+      case "h":
+        result.hourCycle = "h12";
+        result.hour = ["numeric", "2-digit"][len - 1];
+        break;
+      case "H":
+        result.hourCycle = "h23";
+        result.hour = ["numeric", "2-digit"][len - 1];
+        break;
+      case "K":
+        result.hourCycle = "h11";
+        result.hour = ["numeric", "2-digit"][len - 1];
+        break;
+      case "k":
+        result.hourCycle = "h24";
+        result.hour = ["numeric", "2-digit"][len - 1];
+        break;
+      case "j":
+      case "J":
+      case "C":
+        throw new RangeError("`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead");
+      case "m":
+        result.minute = ["numeric", "2-digit"][len - 1];
+        break;
+      case "s":
+        result.second = ["numeric", "2-digit"][len - 1];
+        break;
+      case "S":
+      case "A":
+        throw new RangeError("`S/A` (second) patterns are not supported, use `s` instead");
+      case "z":
+        result.timeZoneName = len < 4 ? "short" : "long";
+        break;
+      case "Z":
+      case "O":
+      case "v":
+      case "V":
+      case "X":
+      case "x":
+        throw new RangeError("`Z/O/v/V/X/x` (timeZone) patterns are not supported, use `z` instead");
+    }
+    return "";
+  });
+  return result;
+}
+const WHITE_SPACE_REGEX = /[\t-\r \x85\u200E\u200F\u2028\u2029]/i;
+function parseNumberSkeletonFromString(skeleton) {
+  if (skeleton.length === 0) throw new Error("Number skeleton cannot be empty");
+  const stringTokens = skeleton.split(WHITE_SPACE_REGEX).filter((x) => x.length > 0);
+  const tokens = [];
+  for (const stringToken of stringTokens) {
+    let stemAndOptions = stringToken.split("/");
+    if (stemAndOptions.length === 0) throw new Error("Invalid number skeleton");
+    const [stem, ...options] = stemAndOptions;
+    for (const option of options) if (option.length === 0) throw new Error("Invalid number skeleton");
+    tokens.push({
+      stem,
+      options
+    });
+  }
+  return tokens;
+}
+function icuUnitToEcma(unit) {
+  return unit.replace(/^(.*?)-/, "");
+}
+const FRACTION_PRECISION_REGEX = /^\.(?:(0+)(\*)?|(#+)|(0+)(#+))$/g;
+const SIGNIFICANT_PRECISION_REGEX = /^(@+)?(\+|#+)?[rs]?$/g;
+const INTEGER_WIDTH_REGEX = /(\*)(0+)|(#+)(0+)|(0+)/g;
+const CONCISE_INTEGER_WIDTH_REGEX = /^(0+)$/;
+function parseSignificantPrecision(str) {
+  const result = {};
+  if (str[str.length - 1] === "r") result.roundingPriority = "morePrecision";
+  else if (str[str.length - 1] === "s") result.roundingPriority = "lessPrecision";
+  str.replace(SIGNIFICANT_PRECISION_REGEX, function(_, g1, g2) {
+    if (typeof g2 !== "string") {
+      result.minimumSignificantDigits = g1.length;
+      result.maximumSignificantDigits = g1.length;
+    } else if (g2 === "+") result.minimumSignificantDigits = g1.length;
+    else if (g1[0] === "#") result.maximumSignificantDigits = g1.length;
+    else {
+      result.minimumSignificantDigits = g1.length;
+      result.maximumSignificantDigits = g1.length + (typeof g2 === "string" ? g2.length : 0);
+    }
+    return "";
+  });
+  return result;
+}
+function parseSign(str) {
+  switch (str) {
+    case "sign-auto":
+      return { signDisplay: "auto" };
+    case "sign-accounting":
+    case "()":
+      return { currencySign: "accounting" };
+    case "sign-always":
+    case "+!":
+      return { signDisplay: "always" };
+    case "sign-accounting-always":
+    case "()!":
+      return {
+        signDisplay: "always",
+        currencySign: "accounting"
+      };
+    case "sign-except-zero":
+    case "+?":
+      return { signDisplay: "exceptZero" };
+    case "sign-accounting-except-zero":
+    case "()?":
+      return {
+        signDisplay: "exceptZero",
+        currencySign: "accounting"
+      };
+    case "sign-never":
+    case "+_":
+      return { signDisplay: "never" };
+  }
+}
+function parseConciseScientificAndEngineeringStem(stem) {
+  let result;
+  if (stem[0] === "E" && stem[1] === "E") {
+    result = { notation: "engineering" };
+    stem = stem.slice(2);
+  } else if (stem[0] === "E") {
+    result = { notation: "scientific" };
+    stem = stem.slice(1);
+  }
+  if (result) {
+    const signDisplay = stem.slice(0, 2);
+    if (signDisplay === "+!") {
+      result.signDisplay = "always";
+      stem = stem.slice(2);
+    } else if (signDisplay === "+?") {
+      result.signDisplay = "exceptZero";
+      stem = stem.slice(2);
+    }
+    if (!CONCISE_INTEGER_WIDTH_REGEX.test(stem)) throw new Error("Malformed concise eng/scientific notation");
+    result.minimumIntegerDigits = stem.length;
+  }
+  return result;
+}
+function parseNotationOptions(opt) {
+  const result = {};
+  const signOpts = parseSign(opt);
+  if (signOpts) return signOpts;
+  return result;
+}
+function parseNumberSkeleton(tokens) {
+  let result = {};
+  for (const token of tokens) {
+    switch (token.stem) {
+      case "percent":
+      case "%":
+        result.style = "percent";
+        continue;
+      case "%x100":
+        result.style = "percent";
+        result.scale = 100;
+        continue;
+      case "currency":
+        result.style = "currency";
+        result.currency = token.options[0];
+        continue;
+      case "group-off":
+      case ",_":
+        result.useGrouping = false;
+        continue;
+      case "precision-integer":
+      case ".":
+        result.maximumFractionDigits = 0;
+        continue;
+      case "measure-unit":
+      case "unit":
+        result.style = "unit";
+        result.unit = icuUnitToEcma(token.options[0]);
+        continue;
+      case "compact-short":
+      case "K":
+        result.notation = "compact";
+        result.compactDisplay = "short";
+        continue;
+      case "compact-long":
+      case "KK":
+        result.notation = "compact";
+        result.compactDisplay = "long";
+        continue;
+      case "scientific":
+        result = {
+          ...result,
+          notation: "scientific",
+          ...token.options.reduce((all, opt) => ({
+            ...all,
+            ...parseNotationOptions(opt)
+          }), {})
+        };
+        continue;
+      case "engineering":
+        result = {
+          ...result,
+          notation: "engineering",
+          ...token.options.reduce((all, opt) => ({
+            ...all,
+            ...parseNotationOptions(opt)
+          }), {})
+        };
+        continue;
+      case "notation-simple":
+        result.notation = "standard";
+        continue;
+      case "unit-width-narrow":
+        result.currencyDisplay = "narrowSymbol";
+        result.unitDisplay = "narrow";
+        continue;
+      case "unit-width-short":
+        result.currencyDisplay = "code";
+        result.unitDisplay = "short";
+        continue;
+      case "unit-width-full-name":
+        result.currencyDisplay = "name";
+        result.unitDisplay = "long";
+        continue;
+      case "unit-width-iso-code":
+        result.currencyDisplay = "symbol";
+        continue;
+      case "scale":
+        result.scale = parseFloat(token.options[0]);
+        continue;
+      case "rounding-mode-floor":
+        result.roundingMode = "floor";
+        continue;
+      case "rounding-mode-ceiling":
+        result.roundingMode = "ceil";
+        continue;
+      case "rounding-mode-down":
+        result.roundingMode = "trunc";
+        continue;
+      case "rounding-mode-up":
+        result.roundingMode = "expand";
+        continue;
+      case "rounding-mode-half-even":
+        result.roundingMode = "halfEven";
+        continue;
+      case "rounding-mode-half-down":
+        result.roundingMode = "halfTrunc";
+        continue;
+      case "rounding-mode-half-up":
+        result.roundingMode = "halfExpand";
+        continue;
+      case "integer-width":
+        if (token.options.length > 1) throw new RangeError("integer-width stems only accept a single optional option");
+        token.options[0].replace(INTEGER_WIDTH_REGEX, function(_, g1, g2, g3, g4, g5) {
+          if (g1) result.minimumIntegerDigits = g2.length;
+          else if (g3 && g4) throw new Error("We currently do not support maximum integer digits");
+          else if (g5) throw new Error("We currently do not support exact integer digits");
+          return "";
+        });
+        continue;
+    }
+    if (CONCISE_INTEGER_WIDTH_REGEX.test(token.stem)) {
+      result.minimumIntegerDigits = token.stem.length;
+      continue;
+    }
+    if (FRACTION_PRECISION_REGEX.test(token.stem)) {
+      if (token.options.length > 1) throw new RangeError("Fraction-precision stems only accept a single optional option");
+      token.stem.replace(FRACTION_PRECISION_REGEX, function(_, g1, g2, g3, g4, g5) {
+        if (g2 === "*") result.minimumFractionDigits = g1.length;
+        else if (g3 && g3[0] === "#") result.maximumFractionDigits = g3.length;
+        else if (g4 && g5) {
+          result.minimumFractionDigits = g4.length;
+          result.maximumFractionDigits = g4.length + g5.length;
+        } else {
+          result.minimumFractionDigits = g1.length;
+          result.maximumFractionDigits = g1.length;
+        }
+        return "";
+      });
+      const opt = token.options[0];
+      if (opt === "w") result = {
+        ...result,
+        trailingZeroDisplay: "stripIfInteger"
+      };
+      else if (opt) result = {
+        ...result,
+        ...parseSignificantPrecision(opt)
+      };
+      continue;
+    }
+    if (SIGNIFICANT_PRECISION_REGEX.test(token.stem)) {
+      result = {
+        ...result,
+        ...parseSignificantPrecision(token.stem)
+      };
+      continue;
+    }
+    const signOpts = parseSign(token.stem);
+    if (signOpts) result = {
+      ...result,
+      ...signOpts
+    };
+    const conciseScientificAndEngineeringOpts = parseConciseScientificAndEngineeringStem(token.stem);
+    if (conciseScientificAndEngineeringOpts) result = {
+      ...result,
+      ...conciseScientificAndEngineeringOpts
+    };
+  }
+  return result;
+}
+let ErrorKind = /* @__PURE__ */ function(ErrorKind2) {
+  ErrorKind2[ErrorKind2["EXPECT_ARGUMENT_CLOSING_BRACE"] = 1] = "EXPECT_ARGUMENT_CLOSING_BRACE";
+  ErrorKind2[ErrorKind2["EMPTY_ARGUMENT"] = 2] = "EMPTY_ARGUMENT";
+  ErrorKind2[ErrorKind2["MALFORMED_ARGUMENT"] = 3] = "MALFORMED_ARGUMENT";
+  ErrorKind2[ErrorKind2["EXPECT_ARGUMENT_TYPE"] = 4] = "EXPECT_ARGUMENT_TYPE";
+  ErrorKind2[ErrorKind2["INVALID_ARGUMENT_TYPE"] = 5] = "INVALID_ARGUMENT_TYPE";
+  ErrorKind2[ErrorKind2["EXPECT_ARGUMENT_STYLE"] = 6] = "EXPECT_ARGUMENT_STYLE";
+  ErrorKind2[ErrorKind2["INVALID_NUMBER_SKELETON"] = 7] = "INVALID_NUMBER_SKELETON";
+  ErrorKind2[ErrorKind2["INVALID_DATE_TIME_SKELETON"] = 8] = "INVALID_DATE_TIME_SKELETON";
+  ErrorKind2[ErrorKind2["EXPECT_NUMBER_SKELETON"] = 9] = "EXPECT_NUMBER_SKELETON";
+  ErrorKind2[ErrorKind2["EXPECT_DATE_TIME_SKELETON"] = 10] = "EXPECT_DATE_TIME_SKELETON";
+  ErrorKind2[ErrorKind2["UNCLOSED_QUOTE_IN_ARGUMENT_STYLE"] = 11] = "UNCLOSED_QUOTE_IN_ARGUMENT_STYLE";
+  ErrorKind2[ErrorKind2["EXPECT_SELECT_ARGUMENT_OPTIONS"] = 12] = "EXPECT_SELECT_ARGUMENT_OPTIONS";
+  ErrorKind2[ErrorKind2["EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE"] = 13] = "EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE";
+  ErrorKind2[ErrorKind2["INVALID_PLURAL_ARGUMENT_OFFSET_VALUE"] = 14] = "INVALID_PLURAL_ARGUMENT_OFFSET_VALUE";
+  ErrorKind2[ErrorKind2["EXPECT_SELECT_ARGUMENT_SELECTOR"] = 15] = "EXPECT_SELECT_ARGUMENT_SELECTOR";
+  ErrorKind2[ErrorKind2["EXPECT_PLURAL_ARGUMENT_SELECTOR"] = 16] = "EXPECT_PLURAL_ARGUMENT_SELECTOR";
+  ErrorKind2[ErrorKind2["EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT"] = 17] = "EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT";
+  ErrorKind2[ErrorKind2["EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT"] = 18] = "EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT";
+  ErrorKind2[ErrorKind2["INVALID_PLURAL_ARGUMENT_SELECTOR"] = 19] = "INVALID_PLURAL_ARGUMENT_SELECTOR";
+  ErrorKind2[ErrorKind2["DUPLICATE_PLURAL_ARGUMENT_SELECTOR"] = 20] = "DUPLICATE_PLURAL_ARGUMENT_SELECTOR";
+  ErrorKind2[ErrorKind2["DUPLICATE_SELECT_ARGUMENT_SELECTOR"] = 21] = "DUPLICATE_SELECT_ARGUMENT_SELECTOR";
+  ErrorKind2[ErrorKind2["MISSING_OTHER_CLAUSE"] = 22] = "MISSING_OTHER_CLAUSE";
+  ErrorKind2[ErrorKind2["INVALID_TAG"] = 23] = "INVALID_TAG";
+  ErrorKind2[ErrorKind2["INVALID_TAG_NAME"] = 25] = "INVALID_TAG_NAME";
+  ErrorKind2[ErrorKind2["UNMATCHED_CLOSING_TAG"] = 26] = "UNMATCHED_CLOSING_TAG";
+  ErrorKind2[ErrorKind2["UNCLOSED_TAG"] = 27] = "UNCLOSED_TAG";
+  return ErrorKind2;
+}({});
+function isLiteralElement(el) {
+  return el.type === 0;
+}
+function isArgumentElement(el) {
+  return el.type === 1;
+}
+function isNumberElement(el) {
+  return el.type === 2;
+}
+function isDateElement(el) {
+  return el.type === 3;
+}
+function isTimeElement(el) {
+  return el.type === 4;
+}
+function isSelectElement(el) {
+  return el.type === 5;
+}
+function isPluralElement(el) {
+  return el.type === 6;
+}
+function isPoundElement(el) {
+  return el.type === 7;
+}
+function isTagElement(el) {
+  return el.type === 8;
+}
+function isNumberSkeleton(el) {
+  return !!(el && typeof el === "object" && el.type === 0);
+}
+function isDateTimeSkeleton(el) {
+  return !!(el && typeof el === "object" && el.type === 1);
+}
+const SPACE_SEPARATOR_REGEX = /[ \xA0\u1680\u2000-\u200A\u202F\u205F\u3000]/;
+const IDENTIFIER_PREFIX_REGEX = /([^\t-\r -\/:-@\[-\^`\{-~\x85\xA0-\xA7\xA9\xAB\xAC\xAE\xB0\xB1\xB6\xBB\xBF\xD7\xF7\u1680\u2000-\u200A\u2010-\u2029\u202F-\u203E\u2041-\u2053\u2055-\u205F\u2190-\u245F\u2500-\u2775\u2794-\u2BFF\u2E00-\u2E7F\u3000-\u3003\u3008-\u3020\u3030\uFD3E\uFD3F\uFE45\uFE46]*)/g;
+const timeData = {
+  "001": ["H", "h"],
+  "419": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "AC": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "AD": ["H", "hB"],
+  "AE": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "AF": [
+    "H",
+    "hb",
+    "hB",
+    "h"
+  ],
+  "AG": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "AI": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "AL": [
+    "h",
+    "H",
+    "hB"
+  ],
+  "AM": ["H", "hB"],
+  "AO": ["H", "hB"],
+  "AR": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "AS": ["h", "H"],
+  "AT": ["H", "hB"],
+  "AU": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "AW": ["H", "hB"],
+  "AX": ["H"],
+  "AZ": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "BA": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "BB": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "BD": [
+    "h",
+    "hB",
+    "H"
+  ],
+  "BE": ["H", "hB"],
+  "BF": ["H", "hB"],
+  "BG": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "BH": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "BI": ["H", "h"],
+  "BJ": ["H", "hB"],
+  "BL": ["H", "hB"],
+  "BM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "BN": [
+    "hb",
+    "hB",
+    "h",
+    "H"
+  ],
+  "BO": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "BQ": ["H"],
+  "BR": ["H", "hB"],
+  "BS": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "BT": ["h", "H"],
+  "BW": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "BY": ["H", "h"],
+  "BZ": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "CA": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "CC": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "CD": ["hB", "H"],
+  "CF": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "CG": ["H", "hB"],
+  "CH": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "CI": ["H", "hB"],
+  "CK": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "CL": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "CM": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "CN": [
+    "H",
+    "hB",
+    "hb",
+    "h"
+  ],
+  "CO": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "CP": ["H"],
+  "CR": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "CU": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "CV": ["H", "hB"],
+  "CW": ["H", "hB"],
+  "CX": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "CY": [
+    "h",
+    "H",
+    "hb",
+    "hB"
+  ],
+  "CZ": ["H"],
+  "DE": ["H", "hB"],
+  "DG": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "DJ": ["h", "H"],
+  "DK": ["H"],
+  "DM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "DO": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "DZ": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "EA": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "EC": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "EE": ["H", "hB"],
+  "EG": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "EH": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "ER": ["h", "H"],
+  "ES": [
+    "H",
+    "hB",
+    "h",
+    "hb"
+  ],
+  "ET": [
+    "hB",
+    "hb",
+    "h",
+    "H"
+  ],
+  "FI": ["H"],
+  "FJ": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "FK": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "FM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "FO": ["H", "h"],
+  "FR": ["H", "hB"],
+  "GA": ["H", "hB"],
+  "GB": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "GD": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "GE": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "GF": ["H", "hB"],
+  "GG": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "GH": ["h", "H"],
+  "GI": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "GL": ["H", "h"],
+  "GM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "GN": ["H", "hB"],
+  "GP": ["H", "hB"],
+  "GQ": [
+    "H",
+    "hB",
+    "h",
+    "hb"
+  ],
+  "GR": [
+    "h",
+    "H",
+    "hb",
+    "hB"
+  ],
+  "GS": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "GT": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "GU": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "GW": ["H", "hB"],
+  "GY": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "HK": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "HN": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "HR": ["H", "hB"],
+  "HU": ["H", "h"],
+  "IC": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "ID": ["H"],
+  "IE": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "IL": ["H", "hB"],
+  "IM": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "IN": ["h", "H"],
+  "IO": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "IQ": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "IR": ["hB", "H"],
+  "IS": ["H"],
+  "IT": ["H", "hB"],
+  "JE": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "JM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "JO": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "JP": [
+    "H",
+    "K",
+    "h"
+  ],
+  "KE": [
+    "hB",
+    "hb",
+    "H",
+    "h"
+  ],
+  "KG": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "KH": [
+    "hB",
+    "h",
+    "H",
+    "hb"
+  ],
+  "KI": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "KM": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "KN": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "KP": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "KR": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "KW": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "KY": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "KZ": ["H", "hB"],
+  "LA": [
+    "H",
+    "hb",
+    "hB",
+    "h"
+  ],
+  "LB": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "LC": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "LI": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "LK": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "LR": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "LS": ["h", "H"],
+  "LT": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "LU": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "LV": [
+    "H",
+    "hB",
+    "hb",
+    "h"
+  ],
+  "LY": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "MA": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "MC": ["H", "hB"],
+  "MD": ["H", "hB"],
+  "ME": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "MF": ["H", "hB"],
+  "MG": ["H", "h"],
+  "MH": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "MK": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "ML": ["H"],
+  "MM": [
+    "hB",
+    "hb",
+    "H",
+    "h"
+  ],
+  "MN": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "MO": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "MP": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "MQ": ["H", "hB"],
+  "MR": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "MS": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "MT": ["H", "h"],
+  "MU": ["H", "h"],
+  "MV": ["H", "h"],
+  "MW": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "MX": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "MY": [
+    "hb",
+    "hB",
+    "h",
+    "H"
+  ],
+  "MZ": ["H", "hB"],
+  "NA": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "NC": ["H", "hB"],
+  "NE": ["H"],
+  "NF": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "NG": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "NI": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "NL": ["H", "hB"],
+  "NO": ["H", "h"],
+  "NP": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "NR": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "NU": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "NZ": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "OM": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "PA": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "PE": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "PF": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "PG": ["h", "H"],
+  "PH": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "PK": [
+    "h",
+    "hB",
+    "H"
+  ],
+  "PL": ["H", "h"],
+  "PM": ["H", "hB"],
+  "PN": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "PR": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "PS": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "PT": ["H", "hB"],
+  "PW": ["h", "H"],
+  "PY": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "QA": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "RE": ["H", "hB"],
+  "RO": ["H", "hB"],
+  "RS": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "RU": ["H"],
+  "RW": ["H", "h"],
+  "SA": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "SB": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "SC": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "SD": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "SE": ["H"],
+  "SG": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "SH": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "SI": ["H", "hB"],
+  "SJ": ["H"],
+  "SK": ["H"],
+  "SL": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "SM": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "SN": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "SO": ["h", "H"],
+  "SR": ["H", "hB"],
+  "SS": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "ST": ["H", "hB"],
+  "SV": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "SX": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "SY": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "SZ": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "TA": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "TC": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "TD": [
+    "h",
+    "H",
+    "hB"
+  ],
+  "TF": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "TG": ["H", "hB"],
+  "TH": ["H", "h"],
+  "TJ": ["H", "h"],
+  "TL": [
+    "H",
+    "hB",
+    "hb",
+    "h"
+  ],
+  "TM": ["H", "h"],
+  "TN": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "TO": ["h", "H"],
+  "TR": ["H", "hB"],
+  "TT": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "TW": [
+    "hB",
+    "hb",
+    "h",
+    "H"
+  ],
+  "TZ": [
+    "hB",
+    "hb",
+    "H",
+    "h"
+  ],
+  "UA": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "UG": [
+    "hB",
+    "hb",
+    "H",
+    "h"
+  ],
+  "UM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "US": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "UY": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "UZ": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "VA": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "VC": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "VE": [
+    "h",
+    "H",
+    "hB",
+    "hb"
+  ],
+  "VG": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "VI": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "VN": ["H", "h"],
+  "VU": ["h", "H"],
+  "WF": ["H", "hB"],
+  "WS": ["h", "H"],
+  "XK": [
+    "H",
+    "hB",
+    "h"
+  ],
+  "YE": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "YT": ["H", "hB"],
+  "ZA": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "ZM": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "ZW": ["H", "h"],
+  "af-ZA": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "ar-001": [
+    "h",
+    "hB",
+    "hb",
+    "H"
+  ],
+  "ca-ES": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "en-001": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "en-HK": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "en-IL": [
+    "H",
+    "h",
+    "hb",
+    "hB"
+  ],
+  "en-MY": [
+    "h",
+    "hb",
+    "H",
+    "hB"
+  ],
+  "es-BR": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "es-ES": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "es-GQ": [
+    "H",
+    "h",
+    "hB",
+    "hb"
+  ],
+  "fr-CA": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "gl-ES": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "gu-IN": [
+    "hB",
+    "hb",
+    "h",
+    "H"
+  ],
+  "hi-IN": [
+    "hB",
+    "h",
+    "H"
+  ],
+  "it-CH": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "it-IT": [
+    "H",
+    "h",
+    "hB"
+  ],
+  "kn-IN": [
+    "hB",
+    "h",
+    "H"
+  ],
+  "ku-SY": ["H", "hB"],
+  "ml-IN": [
+    "hB",
+    "h",
+    "H"
+  ],
+  "mr-IN": [
+    "hB",
+    "hb",
+    "h",
+    "H"
+  ],
+  "pa-IN": [
+    "hB",
+    "hb",
+    "h",
+    "H"
+  ],
+  "ta-IN": [
+    "hB",
+    "h",
+    "hb",
+    "H"
+  ],
+  "te-IN": [
+    "hB",
+    "h",
+    "H"
+  ],
+  "zu-ZA": [
+    "H",
+    "hB",
+    "hb",
+    "h"
+  ]
+};
+function getBestPattern(skeleton, locale) {
+  let skeletonCopy = "";
+  for (let patternPos = 0; patternPos < skeleton.length; patternPos++) {
+    const patternChar = skeleton.charAt(patternPos);
+    if (patternChar === "j") {
+      let extraLength = 0;
+      while (patternPos + 1 < skeleton.length && skeleton.charAt(patternPos + 1) === patternChar) {
+        extraLength++;
+        patternPos++;
+      }
+      let hourLen = 1 + (extraLength & 1);
+      let dayPeriodLen = extraLength < 2 ? 1 : 3 + (extraLength >> 1);
+      let dayPeriodChar = "a";
+      let hourChar = getDefaultHourSymbolFromLocale(locale);
+      if (hourChar == "H" || hourChar == "k") dayPeriodLen = 0;
+      while (dayPeriodLen-- > 0) skeletonCopy += dayPeriodChar;
+      while (hourLen-- > 0) skeletonCopy = hourChar + skeletonCopy;
+    } else if (patternChar === "J") skeletonCopy += "H";
+    else skeletonCopy += patternChar;
+  }
+  return skeletonCopy;
+}
+function getDefaultHourSymbolFromLocale(locale) {
+  let hourCycle = locale.hourCycle;
+  if (hourCycle === void 0) {
+    const localeWithHourCycles = locale;
+    hourCycle = localeWithHourCycles.getHourCycles?.()[0] ?? localeWithHourCycles.hourCycles?.[0];
+  }
+  if (hourCycle) switch (hourCycle) {
+    case "h24":
+      return "k";
+    case "h23":
+      return "H";
+    case "h12":
+      return "h";
+    case "h11":
+      return "K";
+    default:
+      throw new Error("Invalid hourCycle");
+  }
+  const languageTag = locale.language;
+  let regionTag;
+  if (languageTag !== "root") regionTag = locale.maximize().region;
+  return (timeData[`${languageTag}-${regionTag}`] || timeData[regionTag || ""] || timeData[languageTag || ""] || timeData[`${languageTag}-001`] || timeData["001"])[0].charAt(0);
+}
+const SPACE_SEPARATOR_START_REGEX = new RegExp(`^${SPACE_SEPARATOR_REGEX.source}*`);
+const SPACE_SEPARATOR_END_REGEX = new RegExp(`${SPACE_SEPARATOR_REGEX.source}*$`);
+function createLocation(start, end) {
+  return {
+    start,
+    end
+  };
+}
+const hasNativeFromEntries = !!Object.fromEntries;
+const hasTrimStart = !!String.prototype.trimStart;
+const hasTrimEnd = !!String.prototype.trimEnd;
+const fromEntries = hasNativeFromEntries ? Object.fromEntries : function fromEntries2(entries) {
+  const obj = {};
+  for (const [k, v] of entries) obj[k] = v;
+  return obj;
+};
+const trimStart = hasTrimStart ? function trimStart2(s) {
+  return s.trimStart();
+} : function trimStart3(s) {
+  return s.replace(SPACE_SEPARATOR_START_REGEX, "");
+};
+const trimEnd = hasTrimEnd ? function trimEnd2(s) {
+  return s.trimEnd();
+} : function trimEnd3(s) {
+  return s.replace(SPACE_SEPARATOR_END_REGEX, "");
+};
+let IDENTIFIER_PREFIX_RE = createIdentifierPrefixRegex();
+function createIdentifierPrefixRegex() {
+  try {
+    const regex = new RegExp("([^\\p{White_Space}\\p{Pattern_Syntax}]*)", "yu");
+    if (regex.exec("a ")?.[1] === "a") return regex;
+  } catch {
+  }
+  return IDENTIFIER_PREFIX_REGEX;
+}
+function matchIdentifierAtIndex(s, index) {
+  IDENTIFIER_PREFIX_RE.lastIndex = index;
+  return IDENTIFIER_PREFIX_RE.exec(s)[1] ?? "";
+}
+function plainTopLevelEndPosition(message) {
+  if (message.length === 0) return null;
+  let line = 1;
+  let column = 1;
+  for (let offset = 0; offset < message.length; ) {
+    const code = message.charCodeAt(offset);
+    switch (code) {
+      case 35:
+      case 39:
+      case 60:
+      case 123:
+      case 125:
+        return null;
+    }
+    if (code === 10) {
+      line++;
+      column = 1;
+      offset++;
+    } else {
+      column++;
+      if (code >= 55296 && code <= 56319 && offset + 1 < message.length) {
+        const next = message.charCodeAt(offset + 1);
+        offset += next >= 56320 && next <= 57343 ? 2 : 1;
+      } else offset++;
+    }
+  }
+  return {
+    offset: message.length,
+    line,
+    column
+  };
+}
+var Parser = class {
+  constructor(message, options = {}) {
+    this.message = message;
+    this.position = {
+      offset: 0,
+      line: 1,
+      column: 1
+    };
+    this.ignoreTag = !!options.ignoreTag;
+    this.locale = options.locale;
+    this.requiresOtherClause = !!options.requiresOtherClause;
+    this.shouldParseSkeletons = !!options.shouldParseSkeletons;
+  }
+  parse() {
+    if (this.offset() !== 0) throw Error("parser can only be used once");
+    if (this.message.length > 0) {
+      const firstCode = this.message.charCodeAt(0);
+      if (firstCode !== 35 && firstCode !== 39 && firstCode !== 60 && firstCode !== 123 && firstCode !== 125) {
+        const plainEndPosition = plainTopLevelEndPosition(this.message);
+        if (plainEndPosition) {
+          const start = this.clonePosition();
+          this.position = plainEndPosition;
+          return {
+            val: [{
+              type: 0,
+              value: this.message,
+              location: createLocation(start, this.clonePosition())
+            }],
+            err: null
+          };
+        }
+      }
+    }
+    return this.parseMessage(0, "", false);
+  }
+  parseMessage(nestingLevel, parentArgType, expectingCloseTag) {
+    let elements = [];
+    while (!this.isEOF()) {
+      const char = this.char();
+      if (char === 123) {
+        const result = this.parseArgument(nestingLevel, expectingCloseTag);
+        if (result.err) return result;
+        elements.push(result.val);
+      } else if (char === 125 && nestingLevel > 0) break;
+      else if (char === 35 && (parentArgType === "plural" || parentArgType === "selectordinal")) {
+        const position = this.clonePosition();
+        this.bump();
+        elements.push({
+          type: 7,
+          location: createLocation(position, this.clonePosition())
+        });
+      } else if (char === 60 && !this.ignoreTag && this.peek() === 47) {
+        if (expectingCloseTag) break;
+        else return this.error(26, createLocation(this.clonePosition(), this.clonePosition()));
+      } else if (char === 60 && !this.ignoreTag && _isAlpha(this.peek() || 0)) {
+        const result = this.parseTag(nestingLevel, parentArgType);
+        if (result.err) return result;
+        elements.push(result.val);
+      } else {
+        const result = this.parseLiteral(nestingLevel, parentArgType);
+        if (result.err) return result;
+        elements.push(result.val);
+      }
+    }
+    return {
+      val: elements,
+      err: null
+    };
+  }
+  /**
+  * A tag name must start with an ASCII lower/upper case letter. The grammar is based on the
+  * [custom element name][] except that a dash is NOT always mandatory and uppercase letters
+  * are accepted:
+  *
+  * ```
+  * tag ::= "<" tagName (whitespace)* "/>" | "<" tagName (whitespace)* ">" message "</" tagName (whitespace)* ">"
+  * tagName ::= [a-z] (PENChar)*
+  * PENChar ::=
+  *     "-" | "." | [0-9] | "_" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |
+  *     [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |
+  *     [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
+  * ```
+  *
+  * [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
+  * NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do
+  * since other tag-based engines like React allow it
+  */
+  parseTag(nestingLevel, parentArgType) {
+    const startPosition = this.clonePosition();
+    this.bump();
+    const tagName = this.parseTagName();
+    this.bumpSpace();
+    if (this.bumpIf("/>")) return {
+      val: {
+        type: 0,
+        value: `<${tagName}/>`,
+        location: createLocation(startPosition, this.clonePosition())
+      },
+      err: null
+    };
+    else if (this.bumpIf(">")) {
+      const childrenResult = this.parseMessage(nestingLevel + 1, parentArgType, true);
+      if (childrenResult.err) return childrenResult;
+      const children = childrenResult.val;
+      const endTagStartPosition = this.clonePosition();
+      if (this.bumpIf("</")) {
+        if (this.isEOF() || !_isAlpha(this.char())) return this.error(23, createLocation(endTagStartPosition, this.clonePosition()));
+        const closingTagNameStartPosition = this.clonePosition();
+        if (tagName !== this.parseTagName()) return this.error(26, createLocation(closingTagNameStartPosition, this.clonePosition()));
+        this.bumpSpace();
+        if (!this.bumpIf(">")) return this.error(23, createLocation(endTagStartPosition, this.clonePosition()));
+        return {
+          val: {
+            type: 8,
+            value: tagName,
+            children,
+            location: createLocation(startPosition, this.clonePosition())
+          },
+          err: null
+        };
+      } else return this.error(27, createLocation(startPosition, this.clonePosition()));
+    } else return this.error(23, createLocation(startPosition, this.clonePosition()));
+  }
+  /**
+  * This method assumes that the caller has peeked ahead for the first tag character.
+  */
+  parseTagName() {
+    const startOffset = this.offset();
+    this.bump();
+    while (!this.isEOF() && _isPotentialElementNameChar(this.char())) this.bump();
+    return this.message.slice(startOffset, this.offset());
+  }
+  parseLiteral(nestingLevel, parentArgType) {
+    const start = this.clonePosition();
+    let value = "";
+    while (true) {
+      const parseQuoteResult = this.tryParseQuote(parentArgType);
+      if (parseQuoteResult) {
+        value += parseQuoteResult;
+        continue;
+      }
+      const parseUnquotedResult = this.tryParseUnquoted(nestingLevel, parentArgType);
+      if (parseUnquotedResult) {
+        value += parseUnquotedResult;
+        continue;
+      }
+      const parseLeftAngleResult = this.tryParseLeftAngleBracket();
+      if (parseLeftAngleResult) {
+        value += parseLeftAngleResult;
+        continue;
+      }
+      break;
+    }
+    const location = createLocation(start, this.clonePosition());
+    return {
+      val: {
+        type: 0,
+        value,
+        location
+      },
+      err: null
+    };
+  }
+  tryParseLeftAngleBracket() {
+    if (!this.isEOF() && this.char() === 60 && (this.ignoreTag || !_isAlphaOrSlash(this.peek() || 0))) {
+      this.bump();
+      return "<";
+    }
+    return null;
+  }
+  /**
+  * Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes
+  * a character that requires quoting (that is, "only where needed"), and works the same in
+  * nested messages as on the top level of the pattern. The new behavior is otherwise compatible.
+  */
+  tryParseQuote(parentArgType) {
+    if (this.isEOF() || this.char() !== 39) return null;
+    switch (this.peek()) {
+      case 39:
+        this.bump();
+        this.bump();
+        return "'";
+      case 123:
+      case 60:
+      case 62:
+      case 125:
+        break;
+      case 35:
+        if (parentArgType === "plural" || parentArgType === "selectordinal") break;
+        return null;
+      default:
+        return null;
+    }
+    this.bump();
+    const codePoints = [this.char()];
+    this.bump();
+    while (!this.isEOF()) {
+      const ch = this.char();
+      if (ch === 39) {
+        if (this.peek() === 39) {
+          codePoints.push(39);
+          this.bump();
+        } else {
+          this.bump();
+          break;
+        }
+      } else codePoints.push(ch);
+      this.bump();
+    }
+    return String.fromCodePoint(...codePoints);
+  }
+  tryParseUnquoted(nestingLevel, parentArgType) {
+    if (this.isEOF()) return null;
+    const ch = this.char();
+    if (ch === 60 || ch === 123 || ch === 35 && (parentArgType === "plural" || parentArgType === "selectordinal") || ch === 125 && nestingLevel > 0) return null;
+    else {
+      this.bump();
+      return String.fromCodePoint(ch);
+    }
+  }
+  parseArgument(nestingLevel, expectingCloseTag) {
+    const openingBracePosition = this.clonePosition();
+    this.bump();
+    this.bumpSpace();
+    if (this.isEOF()) return this.error(1, createLocation(openingBracePosition, this.clonePosition()));
+    if (this.char() === 125) {
+      this.bump();
+      return this.error(2, createLocation(openingBracePosition, this.clonePosition()));
+    }
+    let value = this.parseIdentifierIfPossible().value;
+    if (!value) return this.error(3, createLocation(openingBracePosition, this.clonePosition()));
+    this.bumpSpace();
+    if (this.isEOF()) return this.error(1, createLocation(openingBracePosition, this.clonePosition()));
+    switch (this.char()) {
+      case 125:
+        this.bump();
+        return {
+          val: {
+            type: 1,
+            value,
+            location: createLocation(openingBracePosition, this.clonePosition())
+          },
+          err: null
+        };
+      case 44:
+        this.bump();
+        this.bumpSpace();
+        if (this.isEOF()) return this.error(1, createLocation(openingBracePosition, this.clonePosition()));
+        return this.parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition);
+      default:
+        return this.error(3, createLocation(openingBracePosition, this.clonePosition()));
+    }
+  }
+  /**
+  * Advance the parser until the end of the identifier, if it is currently on
+  * an identifier character. Return an empty string otherwise.
+  */
+  parseIdentifierIfPossible() {
+    const startingPosition = this.clonePosition();
+    const startOffset = this.offset();
+    const value = matchIdentifierAtIndex(this.message, startOffset);
+    const endOffset = startOffset + value.length;
+    this.bumpTo(endOffset);
+    return {
+      value,
+      location: createLocation(startingPosition, this.clonePosition())
+    };
+  }
+  parseArgumentOptions(nestingLevel, expectingCloseTag, value, openingBracePosition) {
+    let typeStartPosition = this.clonePosition();
+    let argType = this.parseIdentifierIfPossible().value;
+    let typeEndPosition = this.clonePosition();
+    switch (argType) {
+      case "":
+        return this.error(4, createLocation(typeStartPosition, typeEndPosition));
+      case "number":
+      case "date":
+      case "time": {
+        this.bumpSpace();
+        let styleAndLocation = null;
+        if (this.bumpIf(",")) {
+          this.bumpSpace();
+          const styleStartPosition = this.clonePosition();
+          const result = this.parseSimpleArgStyleIfPossible();
+          if (result.err) return result;
+          const style = trimEnd(result.val);
+          if (style.length === 0) return this.error(6, createLocation(this.clonePosition(), this.clonePosition()));
+          styleAndLocation = {
+            style,
+            styleLocation: createLocation(styleStartPosition, this.clonePosition())
+          };
+        }
+        const argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+        if (argCloseResult.err) return argCloseResult;
+        const location = createLocation(openingBracePosition, this.clonePosition());
+        if (styleAndLocation && styleAndLocation.style.startsWith("::")) {
+          let skeleton = trimStart(styleAndLocation.style.slice(2));
+          if (argType === "number") {
+            const result = this.parseNumberSkeletonFromString(skeleton, styleAndLocation.styleLocation);
+            if (result.err) return result;
+            return {
+              val: {
+                type: 2,
+                value,
+                location,
+                style: result.val
+              },
+              err: null
+            };
+          } else {
+            if (skeleton.length === 0) return this.error(10, location);
+            let dateTimePattern = skeleton;
+            if (this.locale) dateTimePattern = getBestPattern(skeleton, this.locale);
+            const style = {
+              type: 1,
+              pattern: dateTimePattern,
+              location: styleAndLocation.styleLocation,
+              parsedOptions: this.shouldParseSkeletons ? parseDateTimeSkeleton(dateTimePattern) : {}
+            };
+            return {
+              val: {
+                type: argType === "date" ? 3 : 4,
+                value,
+                location,
+                style
+              },
+              err: null
+            };
+          }
+        }
+        return {
+          val: {
+            type: argType === "number" ? 2 : argType === "date" ? 3 : 4,
+            value,
+            location,
+            style: styleAndLocation?.style ?? null
+          },
+          err: null
+        };
+      }
+      case "plural":
+      case "selectordinal":
+      case "select": {
+        const typeEndPosition2 = this.clonePosition();
+        this.bumpSpace();
+        if (!this.bumpIf(",")) return this.error(12, createLocation(typeEndPosition2, { ...typeEndPosition2 }));
+        this.bumpSpace();
+        let identifierAndLocation = this.parseIdentifierIfPossible();
+        let pluralOffset = 0;
+        if (argType !== "select" && identifierAndLocation.value === "offset") {
+          if (!this.bumpIf(":")) return this.error(13, createLocation(this.clonePosition(), this.clonePosition()));
+          this.bumpSpace();
+          const result = this.tryParseDecimalInteger(13, 14);
+          if (result.err) return result;
+          this.bumpSpace();
+          identifierAndLocation = this.parseIdentifierIfPossible();
+          pluralOffset = result.val;
+        }
+        const optionsResult = this.tryParsePluralOrSelectOptions(nestingLevel, argType, expectingCloseTag, identifierAndLocation);
+        if (optionsResult.err) return optionsResult;
+        const argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+        if (argCloseResult.err) return argCloseResult;
+        const location = createLocation(openingBracePosition, this.clonePosition());
+        if (argType === "select") return {
+          val: {
+            type: 5,
+            value,
+            options: fromEntries(optionsResult.val),
+            location
+          },
+          err: null
+        };
+        else return {
+          val: {
+            type: 6,
+            value,
+            options: fromEntries(optionsResult.val),
+            offset: pluralOffset,
+            pluralType: argType === "plural" ? "cardinal" : "ordinal",
+            location
+          },
+          err: null
+        };
+      }
+      default:
+        return this.error(5, createLocation(typeStartPosition, typeEndPosition));
+    }
+  }
+  tryParseArgumentClose(openingBracePosition) {
+    if (this.isEOF() || this.char() !== 125) return this.error(1, createLocation(openingBracePosition, this.clonePosition()));
+    this.bump();
+    return {
+      val: true,
+      err: null
+    };
+  }
+  /**
+  * See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659
+  */
+  parseSimpleArgStyleIfPossible() {
+    let nestedBraces = 0;
+    const startPosition = this.clonePosition();
+    while (!this.isEOF()) switch (this.char()) {
+      case 39: {
+        this.bump();
+        let apostrophePosition = this.clonePosition();
+        if (!this.bumpUntil("'")) return this.error(11, createLocation(apostrophePosition, this.clonePosition()));
+        this.bump();
+        break;
+      }
+      case 123:
+        nestedBraces += 1;
+        this.bump();
+        break;
+      case 125:
+        if (nestedBraces > 0) nestedBraces -= 1;
+        else return {
+          val: this.message.slice(startPosition.offset, this.offset()),
+          err: null
+        };
+        break;
+      default:
+        this.bump();
+    }
+    return {
+      val: this.message.slice(startPosition.offset, this.offset()),
+      err: null
+    };
+  }
+  parseNumberSkeletonFromString(skeleton, location) {
+    let tokens = [];
+    try {
+      tokens = parseNumberSkeletonFromString(skeleton);
+    } catch {
+      return this.error(7, location);
+    }
+    return {
+      val: {
+        type: 0,
+        tokens,
+        location,
+        parsedOptions: this.shouldParseSkeletons ? parseNumberSkeleton(tokens) : {}
+      },
+      err: null
+    };
+  }
+  /**
+  * @param nesting_level The current nesting level of messages.
+  *     This can be positive when parsing message fragment in select or plural argument options.
+  * @param parent_arg_type The parent argument's type.
+  * @param parsed_first_identifier If provided, this is the first identifier-like selector of
+  *     the argument. It is a by-product of a previous parsing attempt.
+  * @param expecting_close_tag If true, this message is directly or indirectly nested inside
+  *     between a pair of opening and closing tags. The nested message will not parse beyond
+  *     the closing tag boundary.
+  */
+  tryParsePluralOrSelectOptions(nestingLevel, parentArgType, expectCloseTag, parsedFirstIdentifier) {
+    let hasOtherClause = false;
+    const options = [];
+    const parsedSelectors = /* @__PURE__ */ new Set();
+    let { value: selector, location: selectorLocation } = parsedFirstIdentifier;
+    while (true) {
+      if (selector.length === 0) {
+        const startPosition = this.clonePosition();
+        if (parentArgType !== "select" && this.bumpIf("=")) {
+          const result = this.tryParseDecimalInteger(16, 19);
+          if (result.err) return result;
+          selectorLocation = createLocation(startPosition, this.clonePosition());
+          selector = this.message.slice(startPosition.offset, this.offset());
+        } else break;
+      }
+      if (parsedSelectors.has(selector)) return this.error(parentArgType === "select" ? 21 : 20, selectorLocation);
+      if (selector === "other") hasOtherClause = true;
+      this.bumpSpace();
+      const openingBracePosition = this.clonePosition();
+      if (!this.bumpIf("{")) return this.error(parentArgType === "select" ? 17 : 18, createLocation(this.clonePosition(), this.clonePosition()));
+      const fragmentResult = this.parseMessage(nestingLevel + 1, parentArgType, expectCloseTag);
+      if (fragmentResult.err) return fragmentResult;
+      const argCloseResult = this.tryParseArgumentClose(openingBracePosition);
+      if (argCloseResult.err) return argCloseResult;
+      options.push([selector, {
+        value: fragmentResult.val,
+        location: createLocation(openingBracePosition, this.clonePosition())
+      }]);
+      parsedSelectors.add(selector);
+      this.bumpSpace();
+      ({ value: selector, location: selectorLocation } = this.parseIdentifierIfPossible());
+    }
+    if (options.length === 0) return this.error(parentArgType === "select" ? 15 : 16, createLocation(this.clonePosition(), this.clonePosition()));
+    if (this.requiresOtherClause && !hasOtherClause) return this.error(22, createLocation(this.clonePosition(), this.clonePosition()));
+    return {
+      val: options,
+      err: null
+    };
+  }
+  tryParseDecimalInteger(expectNumberError, invalidNumberError) {
+    let sign = 1;
+    const startingPosition = this.clonePosition();
+    if (this.bumpIf("+")) ;
+    else if (this.bumpIf("-")) sign = -1;
+    let hasDigits = false;
+    let decimal = 0;
+    while (!this.isEOF()) {
+      const ch = this.char();
+      if (ch >= 48 && ch <= 57) {
+        hasDigits = true;
+        decimal = decimal * 10 + (ch - 48);
+        this.bump();
+      } else break;
+    }
+    const location = createLocation(startingPosition, this.clonePosition());
+    if (!hasDigits) return this.error(expectNumberError, location);
+    decimal *= sign;
+    if (!Number.isSafeInteger(decimal)) return this.error(invalidNumberError, location);
+    return {
+      val: decimal,
+      err: null
+    };
+  }
+  offset() {
+    return this.position.offset;
+  }
+  isEOF() {
+    return this.offset() === this.message.length;
+  }
+  clonePosition() {
+    return {
+      offset: this.position.offset,
+      line: this.position.line,
+      column: this.position.column
+    };
+  }
+  /**
+  * Return the code point at the current position of the parser.
+  * Throws if the index is out of bound.
+  */
+  char() {
+    const offset = this.position.offset;
+    if (offset >= this.message.length) throw Error("out of bound");
+    const code = this.message.codePointAt(offset);
+    if (code === void 0) throw Error(`Offset ${offset} is at invalid UTF-16 code unit boundary`);
+    return code;
+  }
+  error(kind, location) {
+    return {
+      val: null,
+      err: {
+        kind,
+        message: this.message,
+        location
+      }
+    };
+  }
+  /** Bump the parser to the next UTF-16 code unit. */
+  bump() {
+    if (this.isEOF()) return;
+    const code = this.char();
+    if (code === 10) {
+      this.position.line += 1;
+      this.position.column = 1;
+      this.position.offset += 1;
+    } else {
+      this.position.column += 1;
+      this.position.offset += code < 65536 ? 1 : 2;
+    }
+  }
+  /**
+  * If the substring starting at the current position of the parser has
+  * the given prefix, then bump the parser to the character immediately
+  * following the prefix and return true. Otherwise, don't bump the parser
+  * and return false.
+  */
+  bumpIf(prefix) {
+    const offset = this.offset();
+    if (this.message.slice(offset, offset + prefix.length) === prefix) {
+      for (let i = 0; i < prefix.length; i++) this.bump();
+      return true;
+    }
+    return false;
+  }
+  /**
+  * Bump the parser until the pattern character is found and return `true`.
+  * Otherwise bump to the end of the file and return `false`.
+  */
+  bumpUntil(pattern) {
+    const currentOffset = this.offset();
+    const index = this.message.indexOf(pattern, currentOffset);
+    if (index >= 0) {
+      this.bumpTo(index);
+      return true;
+    } else {
+      this.bumpTo(this.message.length);
+      return false;
+    }
+  }
+  /**
+  * Bump the parser to the target offset.
+  * If target offset is beyond the end of the input, bump the parser to the end of the input.
+  */
+  bumpTo(targetOffset) {
+    if (this.offset() > targetOffset) throw Error(`targetOffset ${targetOffset} must be greater than or equal to the current offset ${this.offset()}`);
+    targetOffset = Math.min(targetOffset, this.message.length);
+    while (true) {
+      const offset = this.offset();
+      if (offset === targetOffset) break;
+      if (offset > targetOffset) throw Error(`targetOffset ${targetOffset} is at invalid UTF-16 code unit boundary`);
+      this.bump();
+      if (this.isEOF()) break;
+    }
+  }
+  /** advance the parser through all whitespace to the next non-whitespace code unit. */
+  bumpSpace() {
+    while (!this.isEOF() && _isWhiteSpace(this.char())) this.bump();
+  }
+  /**
+  * Peek at the *next* Unicode codepoint in the input without advancing the parser.
+  * If the input has been exhausted, then this returns null.
+  */
+  peek() {
+    if (this.isEOF()) return null;
+    const code = this.char();
+    const offset = this.offset();
+    return this.message.charCodeAt(offset + (code >= 65536 ? 2 : 1)) ?? null;
+  }
+};
+function _isAlpha(codepoint) {
+  return codepoint >= 97 && codepoint <= 122 || codepoint >= 65 && codepoint <= 90;
+}
+function _isAlphaOrSlash(codepoint) {
+  return _isAlpha(codepoint) || codepoint === 47;
+}
+function _isPotentialElementNameChar(c) {
+  return c === 45 || c === 46 || c >= 48 && c <= 57 || c === 95 || c >= 97 && c <= 122 || c >= 65 && c <= 90 || c == 183 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 893 || c >= 895 && c <= 8191 || c >= 8204 && c <= 8205 || c >= 8255 && c <= 8256 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+}
+function _isWhiteSpace(c) {
+  return c >= 9 && c <= 13 || c === 32 || c === 133 || c >= 8206 && c <= 8207 || c === 8232 || c === 8233;
+}
+function pruneLocation(els) {
+  els.forEach((el) => {
+    delete el.location;
+    if (isSelectElement(el) || isPluralElement(el)) for (const k in el.options) {
+      delete el.options[k].location;
+      pruneLocation(el.options[k].value);
+    }
+    else if (isNumberElement(el) && isNumberSkeleton(el.style)) delete el.style.location;
+    else if ((isDateElement(el) || isTimeElement(el)) && isDateTimeSkeleton(el.style)) delete el.style.location;
+    else if (isTagElement(el)) pruneLocation(el.children);
+  });
+}
+function parse(message, opts = {}) {
+  opts = {
+    shouldParseSkeletons: true,
+    requiresOtherClause: true,
+    ...opts
+  };
+  const result = new Parser(message, opts).parse();
+  if (result.err) {
+    const error = SyntaxError(ErrorKind[result.err.kind]);
+    error.location = result.err.location;
+    error.originalMessage = result.err.message;
+    throw error;
+  }
+  if (!opts?.captureLocation) pruneLocation(result.val);
+  return result.val;
+}
+var FormatError = class extends Error {
+  constructor(msg, code, originalMessage) {
+    super(msg);
+    this.code = code;
+    this.originalMessage = originalMessage;
+  }
+  toString() {
+    return `[formatjs Error: ${this.code}] ${this.message}`;
+  }
+};
+var InvalidValueError = class extends FormatError {
+  constructor(variableId, value, options, originalMessage) {
+    super(`Invalid values for "${variableId}": "${value}". Options are "${Object.keys(options).join('", "')}"`, "INVALID_VALUE", originalMessage);
+  }
+};
+var InvalidValueTypeError = class extends FormatError {
+  constructor(value, type2, originalMessage) {
+    super(`Value for "${value}" must be of type ${type2}`, "INVALID_VALUE", originalMessage);
+  }
+};
+var MissingValueError = class extends FormatError {
+  constructor(variableId, originalMessage) {
+    super(`The intl string context variable "${variableId}" was not provided to the string "${originalMessage}"`, "MISSING_VALUE", originalMessage);
+  }
+};
+function mergeLiteral(parts) {
+  if (parts.length < 2) return parts;
+  return parts.reduce((all, part) => {
+    const lastPart = all[all.length - 1];
+    if (!lastPart || lastPart.type !== 0 || part.type !== 0) all.push(part);
+    else lastPart.value += part.value;
+    return all;
+  }, []);
+}
+function isFormatXMLElementFn(el) {
+  return typeof el === "function";
+}
+function formatToParts(els, locales, formatters, formats2, values, currentPluralValue, originalMessage) {
+  if (els.length === 1 && isLiteralElement(els[0])) return [{
+    type: 0,
+    value: els[0].value
+  }];
+  const result = [];
+  for (const el of els) {
+    if (isLiteralElement(el)) {
+      result.push({
+        type: 0,
+        value: el.value
+      });
+      continue;
+    }
+    if (isPoundElement(el)) {
+      if (typeof currentPluralValue === "number") result.push({
+        type: 0,
+        value: formatters.getNumberFormat(locales).format(currentPluralValue)
+      });
+      continue;
+    }
+    const { value: varName } = el;
+    if (!(values && varName in values)) throw new MissingValueError(varName, originalMessage);
+    let value = values[varName];
+    if (isArgumentElement(el)) {
+      if (!value || typeof value === "string" || typeof value === "number" || typeof value === "bigint") value = typeof value === "string" || typeof value === "number" || typeof value === "bigint" ? String(value) : "";
+      result.push({
+        type: typeof value === "string" ? 0 : 1,
+        value
+      });
+      continue;
+    }
+    if (isDateElement(el)) {
+      const style = typeof el.style === "string" ? formats2.date[el.style] : isDateTimeSkeleton(el.style) ? el.style.parsedOptions : void 0;
+      result.push({
+        type: 0,
+        value: formatters.getDateTimeFormat(locales, style).format(value)
+      });
+      continue;
+    }
+    if (isTimeElement(el)) {
+      const style = typeof el.style === "string" ? formats2.time[el.style] : isDateTimeSkeleton(el.style) ? el.style.parsedOptions : formats2.time.medium;
+      result.push({
+        type: 0,
+        value: formatters.getDateTimeFormat(locales, style).format(value)
+      });
+      continue;
+    }
+    if (isNumberElement(el)) {
+      const style = typeof el.style === "string" ? formats2.number[el.style] : isNumberSkeleton(el.style) ? el.style.parsedOptions : void 0;
+      if (style && style.scale) {
+        const scale = style.scale || 1;
+        if (typeof value === "bigint") {
+          if (!Number.isInteger(scale)) throw new TypeError(`Cannot apply fractional scale ${scale} to bigint value. Scale must be an integer when formatting bigint.`);
+          value = value * BigInt(scale);
+        } else value = value * scale;
+      }
+      result.push({
+        type: 0,
+        value: formatters.getNumberFormat(locales, style).format(value)
+      });
+      continue;
+    }
+    if (isTagElement(el)) {
+      const { children, value: value2 } = el;
+      const formatFn = values[value2];
+      if (!isFormatXMLElementFn(formatFn)) throw new InvalidValueTypeError(value2, "function", originalMessage);
+      let chunks = formatFn(formatToParts(children, locales, formatters, formats2, values, currentPluralValue).map((p) => p.value));
+      if (!Array.isArray(chunks)) chunks = [chunks];
+      result.push(...chunks.map((c) => {
+        return {
+          type: typeof c === "string" ? 0 : 1,
+          value: c
+        };
+      }));
+    }
+    if (isSelectElement(el)) {
+      const key = value;
+      const opt = (Object.prototype.hasOwnProperty.call(el.options, key) ? el.options[key] : void 0) || el.options.other;
+      if (!opt) throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
+      result.push(...formatToParts(opt.value, locales, formatters, formats2, values));
+      continue;
+    }
+    if (isPluralElement(el)) {
+      const exactKey = `=${value}`;
+      let opt = Object.prototype.hasOwnProperty.call(el.options, exactKey) ? el.options[exactKey] : void 0;
+      if (!opt) {
+        if (!Intl.PluralRules) throw new FormatError(`Intl.PluralRules is not available in this environment.
+Try polyfilling it using "@formatjs/intl-pluralrules"
+`, "MISSING_INTL_API", originalMessage);
+        const numericValue2 = typeof value === "bigint" ? Number(value) : value;
+        const rule = formatters.getPluralRules(locales, { type: el.pluralType }).select(numericValue2 - (el.offset || 0));
+        opt = (Object.prototype.hasOwnProperty.call(el.options, rule) ? el.options[rule] : void 0) || el.options.other;
+      }
+      if (!opt) throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
+      const numericValue = typeof value === "bigint" ? Number(value) : value;
+      result.push(...formatToParts(opt.value, locales, formatters, formats2, values, numericValue - (el.offset || 0)));
+      continue;
+    }
+  }
+  return mergeLiteral(result);
+}
+function mergeConfig(c1, c2) {
+  if (!c2) return c1;
+  return {
+    ...c1,
+    ...c2,
+    ...Object.keys(c1).reduce((all, k) => {
+      all[k] = {
+        ...c1[k],
+        ...c2[k]
+      };
+      return all;
+    }, {})
+  };
+}
+function mergeConfigs(defaultConfig, configs) {
+  if (!configs) return defaultConfig;
+  return Object.keys(defaultConfig).reduce((all, k) => {
+    all[k] = mergeConfig(defaultConfig[k], configs[k]);
+    return all;
+  }, { ...defaultConfig });
+}
+function createFastMemoizeCache(store) {
+  return { create() {
+    return {
+      get(key) {
+        return store[key];
+      },
+      set(key, value) {
+        store[key] = value;
+      }
+    };
+  } };
+}
+function createDefaultFormatters(cache = {
+  number: {},
+  dateTime: {},
+  pluralRules: {}
+}) {
+  return {
+    getNumberFormat: memoize((...args) => new Intl.NumberFormat(...args), {
+      cache: createFastMemoizeCache(cache.number),
+      strategy: strategies.variadic
+    }),
+    getDateTimeFormat: memoize((...args) => new Intl.DateTimeFormat(...args), {
+      cache: createFastMemoizeCache(cache.dateTime),
+      strategy: strategies.variadic
+    }),
+    getPluralRules: memoize((...args) => new Intl.PluralRules(...args), {
+      cache: createFastMemoizeCache(cache.pluralRules),
+      strategy: strategies.variadic
+    })
+  };
+}
+var IntlMessageFormat = class IntlMessageFormat2 {
+  constructor(message, locales = IntlMessageFormat2.defaultLocale, overrideFormats, opts) {
+    this.formatterCache = {
+      number: {},
+      dateTime: {},
+      pluralRules: {}
+    };
+    this.format = (values) => {
+      const parts = this.formatToParts(values);
+      if (parts.length === 1) return parts[0].value;
+      const result = parts.reduce((all, part) => {
+        if (!all.length || part.type !== 0 || typeof all[all.length - 1] !== "string") all.push(part.value);
+        else all[all.length - 1] += part.value;
+        return all;
+      }, []);
+      if (result.length <= 1) return result[0] || "";
+      return result;
+    };
+    this.formatToParts = (values) => formatToParts(this.ast, this.locales, this.formatters, this.formats, values, void 0, this.message);
+    this.resolvedOptions = () => ({ locale: this.resolvedLocale?.toString() || Intl.NumberFormat.supportedLocalesOf(this.locales)[0] });
+    this.getAst = () => this.ast;
+    this.locales = locales;
+    this.resolvedLocale = IntlMessageFormat2.resolveLocale(locales);
+    if (typeof message === "string") {
+      this.message = message;
+      if (!IntlMessageFormat2.__parse) throw new TypeError("IntlMessageFormat.__parse must be set to process `message` of type `string`");
+      const { ...parseOpts } = opts || {};
+      this.ast = IntlMessageFormat2.__parse(message, {
+        ...parseOpts,
+        locale: this.resolvedLocale
+      });
+    } else this.ast = message;
+    if (!Array.isArray(this.ast)) throw new TypeError("A message must be provided as a String or AST.");
+    this.formats = mergeConfigs(IntlMessageFormat2.formats, overrideFormats);
+    this.formatters = opts && opts.formatters || createDefaultFormatters(this.formatterCache);
+  }
+  static {
+    this.memoizedDefaultLocale = null;
+  }
+  static get defaultLocale() {
+    if (!IntlMessageFormat2.memoizedDefaultLocale) IntlMessageFormat2.memoizedDefaultLocale = new Intl.NumberFormat().resolvedOptions().locale;
+    return IntlMessageFormat2.memoizedDefaultLocale;
+  }
+  static {
+    this.resolveLocale = (locales) => {
+      if (typeof Intl.Locale === "undefined") return;
+      const supportedLocales = Intl.NumberFormat.supportedLocalesOf(locales);
+      if (supportedLocales.length > 0) return new Intl.Locale(supportedLocales[0]);
+      return new Intl.Locale(typeof locales === "string" ? locales : locales[0]);
+    };
+  }
+  static {
+    this.__parse = parse;
+  }
+  static {
+    this.formats = {
+      number: {
+        integer: { maximumFractionDigits: 0 },
+        currency: { style: "currency" },
+        percent: { style: "percent" }
+      },
+      date: {
+        short: {
+          month: "numeric",
+          day: "numeric",
+          year: "2-digit"
+        },
+        medium: {
+          month: "short",
+          day: "numeric",
+          year: "numeric"
+        },
+        long: {
+          month: "long",
+          day: "numeric",
+          year: "numeric"
+        },
+        full: {
+          weekday: "long",
+          month: "long",
+          day: "numeric",
+          year: "numeric"
+        }
+      },
+      time: {
+        short: {
+          hour: "numeric",
+          minute: "numeric"
+        },
+        medium: {
+          hour: "numeric",
+          minute: "numeric",
+          second: "numeric"
+        },
+        long: {
+          hour: "numeric",
+          minute: "numeric",
+          second: "numeric",
+          timeZoneName: "short"
+        },
+        full: {
+          hour: "numeric",
+          minute: "numeric",
+          second: "numeric",
+          timeZoneName: "short"
+        }
+      }
+    };
+  }
+};
+const enUiAgents = {};
+const enUiBrowserChrome = {
+  "ui.browser.chrome.approvals": "Approvals and site access",
+  "ui.browser.chrome.error_title": "Page failed to load",
+  "ui.browser.chrome.move_left": "Move tab left",
+  "ui.browser.chrome.move_right": "Move tab right",
+  "ui.browser.chrome.duplicate": "Duplicate tab",
+  "ui.browser.chrome.reload": "Reload tab",
+  "ui.browser.chrome.scroll_left": "Scroll tabs left",
+  "ui.browser.chrome.scroll_right": "Scroll tabs right",
+  "ui.browser.chrome.accessible_tab": "{title}{loading, select, yes{, loading} other{}}{failed, select, yes{, failed to load} other{}}{owner, select, agent{, agent-owned} shared{, shared with an agent} other{}}{waiting, select, none{} other{, request {waiting} waiting}}{restored, select, yes{, restored} other{}}",
+  "ui.browser.chrome.invalid_order": "Invalid browser tab order.",
+  "ui.browser.chrome.duplicate_refused": "Only web pages can be duplicated.",
+  "ui.browser.chrome.invalid_action": "Invalid browser tab action.",
+  "ui.browser.chrome.tab_gone": "That browser tab is no longer open.",
+  "ui.browser.chrome.operation_failed": "{action, select, duplicate{The tab could not be duplicated. You can retry from its menu.} other{The tab could not be reloaded. You can retry from its menu.}}"
+};
+const enUiBrowser = {};
+const enUiCanvas = {
+  "ui.canvas.files.highlights": "Highlights",
+  "ui.canvas.files.working": "Working files",
+  "ui.canvas.files.images": "Images",
+  "ui.canvas.files.videos": "Videos",
+  "ui.canvas.files.documents": "Documents",
+  "ui.canvas.files.spreadsheets": "Spreadsheets",
+  "ui.canvas.files.other": "Other",
+  "ui.canvas.files.audio": "Audio",
+  "ui.canvas.files.code": "Code",
+  "ui.canvas.files.presentations": "Presentations",
+  "ui.canvas.files.archives": "Archives",
+  "ui.canvas.files.files": "Files",
+  "ui.canvas.files.search": "Search files by name or folder",
+  "ui.canvas.files.searchPlaceholder": "Search files",
+  "ui.canvas.files.sort": "Sort by",
+  "ui.canvas.files.order": "Order",
+  "ui.canvas.files.group": "Group by kind",
+  "ui.canvas.files.recent": "Mentioned",
+  "ui.canvas.files.name": "Name",
+  "ui.canvas.files.kind": "Kind",
+  "ui.canvas.files.modified": "Modified",
+  "ui.canvas.files.created": "Created",
+  "ui.canvas.files.size": "Size",
+  "ui.canvas.files.filter": "Filter",
+  "ui.canvas.files.reset": "Reset filter",
+  "ui.canvas.files.folder": "Open folder",
+  "ui.canvas.files.loading": "Loading session files…",
+  "ui.canvas.files.progress": "{loaded} of {total} loaded",
+  "ui.canvas.files.building": "Building the file index…",
+  "ui.canvas.files.retry": "Retry",
+  "ui.canvas.files.continue": "Continue loading",
+  "ui.canvas.files.empty": "No files yet",
+  "ui.canvas.files.emptyDetail": "Files the agent creates or highlights appear here.",
+  "ui.canvas.files.noMatch": "No files match this search and filter",
+  "ui.canvas.files.clear": "Clear search and filter",
+  "ui.canvas.files.sessionOnly": "In conversation only",
+  "ui.canvas.files.missing": "No longer on disk",
+  "ui.canvas.files.tooLarge": "Too large to preview",
+  "ui.canvas.files.unreadable": "Could not be read",
+  "ui.canvas.files.expand": "Expand image",
+  "ui.canvas.files.play": "Open to play",
+  "ui.canvas.files.asc": "Ascending",
+  "ui.canvas.files.desc": "Descending",
+  "ui.canvas.files.region": "Session files",
+  "ui.canvas.files.readingStats": "Reading file details…",
+  "ui.canvas.files.error": "Could not load session files",
+  "ui.canvas.files.remote": "Remote files are unavailable here",
+  "ui.canvas.files.inSession": "In session",
+  "ui.canvas.files.count": "{count, plural, one {# file} other {# files}}",
+  "ui.canvas.files.narrowCount": "{shown} of {total} files",
+  "ui.canvas.files.gone": "No longer in the session",
+  "ui.canvas.files.earlier": "Search earlier messages",
+  "ui.canvas.files.imageActions": "Image actions",
+  "ui.canvas.files.fileActions": "File actions",
+  "ui.canvas.files.saveError": "Could not save the file",
+  "ui.canvas.files.prepareError": "Could not prepare a local copy for this action",
+  "ui.canvas.files.pathCopyNote": "Open, folder and path actions create a local copy in this conversation's scratchpad."
+};
+const enUiChat = {
+  "ui.chat.usage.continue": "Included quota used; credits will continue.",
+  "ui.chat.usage.family_caps": "Model-family caps still apply.",
+  "ui.chat.usage.blocked": "Spend unavailable",
+  "ui.chat.usage.eligibility_unknown": "Spend eligibility unknown",
+  "ui.chat.usage.unlimited": "Unlimited paid allowance",
+  "ui.chat.highlights.file_resolution_failed": "Couldn't resolve this file in the session working directory. Use Copy file path to check its location against this session's workspace before trying again."
+};
+const enUiConsole = {
+  "ui.console.capacity.summary": "{live, number} live of {limit, number} in the app",
+  "ui.console.capacity.summary_compact": "{live, number}/{limit, number} · {archived, number} kept",
+  "ui.console.capacity.summary_compact_bare": "{live, number}/{limit, number}",
+  "ui.console.capacity.archived": " · {archived, number} kept",
+  "ui.console.capacity.full": " · full",
+  "ui.console.capacity.help": "App-wide counts, across every conversation. Kept history does not use a process slot.",
+  "ui.console.capacity.resources": "Modeled managed storage: {memory, number} MiB. Logs: {logs, number} MiB. Pending output: {pending, number} MiB. Terminal cells: {cells, number}. Protected terminals: {protected, number}. This excludes child-process memory.",
+  "ui.console.cleanup.label": "Clear finished agent terminals",
+  "ui.console.cleanup.help": "Clears finished agent terminals in this conversation. Finished ones the agent asked to keep stay on disk; the rest are closed and their output is not kept. Terminals you opened, and any in use, are left alone.",
+  "ui.console.cleanup.result": "Cleared {released, plural, one {# finished agent terminal} other {# finished agent terminals}}. {protected, plural, =0 {} one {# is still in use and was left open.} other {# are still in use and were left open.}}",
+  "ui.console.cleanup.result_none": "Nothing to clear — no finished agent terminals in this conversation.",
+  "ui.console.dismiss_history": "Clear terminal and delete retained output",
+  "ui.console.dismiss.body": "Clearing this terminal deletes its retained output from disk, so a relaunch cannot restore it.",
+  "ui.console.dismiss.title": "Clear this terminal?",
+  "ui.console.dismiss.confirm": "Clear terminal",
+  "ui.console.close.body": "This ends the program running here and removes its tab.",
+  "ui.console.close.busy": "Closing…",
+  "ui.console.close.confirm": "Close terminal",
+  "ui.console.close.kept": "Its output is kept.",
+  "ui.console.close.title": "Close this terminal?",
+  "ui.console.create_failed.detail": "The console host is running, and refused to start a program for this conversation — so this is one attempt failing rather than the console being switched off. Trying again is the first thing to do; if it keeps failing, the line below is the host's own reason.",
+  "ui.console.create_failed.retry": "Try again",
+  "ui.console.create_failed.title": "The console could not start in this session",
+  "ui.console.empty.detail": "A console runs a program in this conversation's directory and keeps its output, whether or not this pane is open.",
+  "ui.console.empty.title": "No console in this session",
+  "ui.console.ended.exit_code": "exit code {code}",
+  "ui.console.ended.exit_unknown": "exit code not observed",
+  "ui.console.ended.live": "This terminal has ended",
+  "ui.console.ended.restored": "This terminal has ended and its history was restored",
+  "ui.console.loading.create": "Starting a console",
+  "ui.console.loading.read": "Reading this session's console",
+  "ui.console.new": "New console",
+  "ui.console.pane.blip": "Finished since you last looked",
+  "ui.console.pane.close": "Close console",
+  "ui.console.pane.close_refusal": "The terminal could not be closed.",
+  "ui.console.pane.label": "Console",
+  "ui.console.pane.needs_conversation.detail": "A console runs in a conversation's working directory, so there is nowhere to put one yet.",
+  "ui.console.pane.needs_conversation.title": "A console needs a conversation",
+  "ui.console.pane.surfaces": "Console surfaces",
+  "ui.console.secure": "Secure input is on: what you type here is not recorded.",
+  "ui.console.unavailable.disabled.detail": "LOCAL_OPERATOR_UI_CONSOLE_HOST is set to 0 in this app's environment, so no terminal is started and no surface can be created. Removing that setting turns the console back on.",
+  "ui.console.unavailable.disabled.title": "The console is switched off for this run",
+  "ui.console.unavailable.pty.detail": "Terminal support did not load for this run. Updating Local Operator restores it, and the app's log names the reason.",
+  "ui.console.unavailable.title": "The console is not available in this app",
+  "ui.console.unavailable.unknown.detail": "This window could not reach the console, and did not say why. The app's log carries the reason.",
+  "ui.console.tab.ended": "ended",
+  "ui.console.tab.agent_opened": "An agent opened this console",
+  "ui.console.tab.agent_typed": "An agent has typed into this console",
+  "ui.console.tab.close_label": "Close {title}, tab {index, number} of {total, number}",
+  "ui.console.tab.clear_label": "Clear {title}, tab {index, number} of {total, number}",
+  "ui.console.tab.clear_label_retained": "Clear {title}, tab {index, number} of {total, number} — deletes retained output",
+  "ui.console.secure_toggle.stop": "Stop secure input",
+  "ui.console.secure_toggle.start": "Secure input",
+  "ui.console.secure_toggle.start_tooltip": "Secure input: stop recording this terminal",
+  "ui.console.close.cancel": "Cancel",
+  "ui.console.terminal.prompt_label": "Terminal input",
+  "ui.console.terminal.too_much_output": "Too much output to announce, navigate to rows manually to read"
+};
+const enUiHub = {
+  "ui.hub.links.title": "Hub links",
+  "ui.hub.links.loading": "Loading hub links…",
+  "ui.hub.links.empty": "Not linked to the hub.",
+  "ui.hub.links.load_failed": "Hub links could not be loaded. Retry.",
+  "ui.hub.links.retry": "Retry",
+  "ui.hub.links.source_public": "Public",
+  "ui.hub.links.source_private": "{organization} · Private",
+  "ui.hub.links.source_unavailable": "Source unavailable",
+  "ui.hub.links.source_address": "Hub source: {address}",
+  "ui.hub.subscriptions.subscribe": "Subscribe",
+  "ui.hub.subscriptions.subscribe_description": "Receive updates from {source}. Manual pull stays available.",
+  "ui.hub.subscriptions.auto_push": "Auto-push",
+  "ui.hub.subscriptions.auto_push_description": "Publish local changes to {source} automatically when safe.",
+  "ui.hub.subscriptions.configured_on": "On",
+  "ui.hub.subscriptions.configured_off": "Off",
+  "ui.hub.subscriptions.effective_paused": "Paused — {reason}",
+  "ui.hub.subscriptions.effective_ready": "Ready when there are safe changes.",
+  "ui.hub.subscriptions.saving": "Saving {setting} for {source}…",
+  "ui.hub.subscriptions.save_failed": "Couldn’t save {setting} for {source}. Try again.",
+  "ui.hub.subscriptions.policy_changed": "This policy changed elsewhere. Review the latest values before trying again.",
+  "ui.hub.subscriptions.check": "Check now",
+  "ui.hub.subscriptions.pull": "Pull now",
+  "ui.hub.subscriptions.preview_publish": "Preview publish",
+  "ui.hub.subscriptions.enable_title": "Enable auto-push to {source}?",
+  "ui.hub.subscriptions.enable_public": "Future changes to {item} may be published publicly without asking each time. Changes from private sources are paused for review. Turning auto-push off later stops future publishing, but it does not take back anything that is already public.",
+  "ui.hub.subscriptions.enable_private": "Future changes to {item} may be published to {organization} without asking each time. Only people allowed to access that organization can receive them.",
+  "ui.hub.subscriptions.enable_safety": "Concurrent changes on the hub are merged or paused for review, never overwritten silently.",
+  "ui.hub.subscriptions.cancel": "Cancel",
+  "ui.hub.subscriptions.enable": "Enable auto-push",
+  "ui.hub.subscriptions.unsupported": "The destination has not verified safe automatic publication.",
+  "ui.hub.subscriptions.manual_available": "Incoming updates are off. Manual check and pull remain available.",
+  "ui.hub.subscriptions.subscribe_description_blocked": "Receive updates from {source}.",
+  "ui.hub.subscriptions.incoming_paused": "Incoming updates paused.",
+  "ui.hub.subscriptions.outgoing_paused": "Outgoing changes may still be published to {source}.",
+  "ui.hub.links.last_success": "Last successful action: {time}",
+  "ui.hub.links.actual_model": "Model used: {model}",
+  "ui.hub.links.healthy": "{item} from {source}; Subscribe {subscribe}; Auto-push {autoPush}. Open link policies.",
+  "ui.hub.links.available": "Update {item} from {source}",
+  "ui.hub.links.failed": "Retry {direction} for {item} at {source}",
+  "ui.hub.links.busy": "{direction} in progress for {item} at {source}",
+  "ui.hub.links.updated": "Updated {item} from {source}",
+  "ui.hub.links.published": "Published {item} to {source}",
+  "ui.hub.subscriptions.policy_menu": "Link policies for {item} at {source}",
+  "ui.hub.subscriptions.copy_needed": "Separate copy needed for subscription.",
+  "ui.hub.subscriptions.open_copy": "Open copy",
+  "ui.hub.subscriptions.create_copy": "Create linked copy",
+  "ui.hub.subscriptions.alias": "Local alias",
+  "ui.hub.subscriptions.source_separation": "This copy is linked to {currentSource}. Updates from {newSource} will use a separate local copy.",
+  "ui.hub.skills.title": "Skills",
+  "ui.hub.skills.empty": "No skills installed.",
+  "ui.hub.skills.search_empty": "No skills match this search.",
+  "ui.hub.skills.loading": "Loading skills…",
+  "ui.hub.skills.unavailable": "This server does not support the hub skills catalogue.",
+  "ui.hub.links.confirm_publish": "Publish reviewed changes",
+  "ui.hub.links.preview_changed": "The hub, this copy, or its policy changed. Review a new preview before publishing.",
+  "ui.hub.links.preview_expired": "This preview expired. Review a new preview before publishing.",
+  "ui.hub.links.preview_payload": "Reviewed publication to {source}",
+  "ui.hub.links.direction_pull": "Incoming update",
+  "ui.hub.links.direction_push": "Outgoing publication",
+  "ui.hub.links.action_failed": "The {direction} for {item} at {source} did not complete. Review its status before trying again.",
+  "ui.hub.links.preview_warnings": "Review notes",
+  "ui.hub.links.action_result": "{direction} for {item} at {source}: {outcome}",
+  "ui.hub.links.preview_pull": "Preview incoming changes",
+  "ui.hub.links.prefer_local": "Keep mine",
+  "ui.hub.links.prefer_remote": "Use the hub’s",
+  "ui.hub.links.unknown_baseline": "This copy has no verified common baseline. Review both versions before applying changes.",
+  "ui.hub.links.acknowledge_baseline": "I reviewed both versions and understand that the previous baseline is unknown.",
+  "ui.hub.skills.remote_empty": "No skills have been published here yet.",
+  "ui.hub.skills.scope": "Skills from {source}",
+  "ui.hub.skills.pull_title": "Pull {item} from {source}",
+  "ui.hub.skills.pull_help": "Create a separate local copy with its own source and policy. Existing copies are not overwritten.",
+  "ui.hub.skills.pull_failed": "The pull was not confirmed. Check linked items before trying again.",
+  "ui.hub.skills.policy_pending": "Publication succeeded, but this machine has not confirmed the link policies. Reconcile this publication before another write.",
+  "ui.hub.skills.publish_title": "Publish a skill",
+  "ui.hub.skills.select_authored": "Authored skill",
+  "ui.hub.skills.revision": "Remote revision: {revision}",
+  "ui.hub.skills.file_count": "{count, plural, one {# file included} other {# files included}}",
+  "ui.hub.skills.files": "Files included",
+  "ui.hub.skills.text_limits": "Skills support up to 64 UTF-8 text files, 200 KiB per file and 1 MiB in total. Scripts are never run when publishing or pulling.",
+  "ui.hub.skills.local_exists": "That local alias is already used. Choose another.",
+  "ui.hub.skills.initial_policy_description": "New links subscribe to incoming updates. Auto-push stays off until enabled for this destination.",
+  "ui.hub.status.not_checked": "Not checked yet.",
+  "ui.hub.status.idle": "No changes waiting.",
+  "ui.hub.status.checking": "Checking for changes…",
+  "ui.hub.status.available": "Changes are available.",
+  "ui.hub.status.merging": "Merging changes…",
+  "ui.hub.status.applying": "Applying incoming changes…",
+  "ui.hub.status.pushing": "Publishing outgoing changes…",
+  "ui.hub.status.retry_wait": "A retry is scheduled.",
+  "ui.hub.status.needs_review": "Review is needed before changes can be applied.",
+  "ui.hub.status.failed": "The last action did not complete.",
+  "ui.hub.status.missing": "The source is missing or access is no longer available.",
+  "ui.hub.status.unknown": "Status unavailable.",
+  "ui.hub.status.next_retry": "Next retry: {time}",
+  "ui.hub.status.last_checked": "Last checked: {time}",
+  "ui.hub.status.attempts": "{count, plural, one {# attempt} other {# attempts}}",
+  "ui.hub.status.receipt": "Operation receipt: {operation}",
+  "ui.hub.status.core_update_required": "Update the Local Operator backend to a published release {minimum} or newer to change Hub settings. Browsing is still available.",
+  "ui.hub.status.backend_checking": "Checking the Local Operator backend before allowing Hub changes. Browsing is still available.",
+  "ui.hub.status.backend_disconnected": "Reconnect the Local Operator backend to change Hub settings. Backend {minimum} or newer is required; browsing is still available.",
+  "ui.hub.status.unsupported": "This destination has not verified revision-safe publication.",
+  "ui.hub.status.baseline_unknown": "The common baseline could not be verified. Review both versions first.",
+  "ui.hub.status.mixed_lineage": "This copy includes changes from another source. Automatic publication is paused.",
+  "ui.hub.status.no_credential": "Sign in to the hub before trying this action.",
+  "ui.hub.status.access_lost": "Access to this private source is no longer available.",
+  "ui.hub.status.provider_error": "The current default model could not be reached. A retry can use the latest state.",
+  "ui.hub.status.model_unavailable": "The current default model is unavailable. Check its configuration.",
+  "ui.hub.status.conflict": "Concurrent changes need review. Your copy has not been replaced.",
+  "ui.hub.status.too_large": "These changes exceed the safe processing limit. Your copy has been preserved.",
+  "ui.hub.status.skill_validation": "The skill does not meet the required file and metadata rules.",
+  "ui.hub.status.unsafe_publication": "This destination cannot safely receive the current content. Review the destination-specific copy.",
+  "ui.hub.status.other_error": "This action is paused.",
+  "ui.hub.skills.search": "Search skills",
+  "ui.hub.skills.search_loaded": "Search covers this loaded page.",
+  "ui.hub.skills.open_detail": "View {item}",
+  "ui.hub.skills.catalogue_failed": "Skills from {source} could not be loaded. Retry.",
+  "ui.hub.skills.installed_alias": "Pulled {item} from {source}",
+  "ui.hub.skills.session_selection": "Skill files are available on their next read. Newly selected skill descriptions are included in the next session.",
+  "ui.hub.links.publication_pending": "The publication outcome is not yet confirmed. Retry this same operation to reconcile it.",
+  "ui.hub.links.resolve_title": "Confirm this link’s source",
+  "ui.hub.links.resolve_description": "Only confirm if you know {item} came from here.",
+  "ui.hub.links.resolve_action": "Confirm source",
+  "ui.hub.links.resolve_conflict": "That source conflicts with the stored origin. Nothing was changed.",
+  "ui.hub.links.scope_label": "Publish scope",
+  "ui.hub.links.scope_public": "Public",
+  "ui.hub.links.scope_private": "{organization} · Private",
+  "ui.hub.links.sign_in_to_publish": "Sign in to choose a publish scope",
+  "ui.hub.links.resolve_action_confirm": "Confirm this source",
+  "ui.hub.links.resolve_action_confirming": "Confirming…",
+  "ui.hub.links.resolve_action_done": "Source confirmed",
+  "ui.hub.links.resolve_failed_generic": "The source could not be confirmed.",
+  "ui.hub.links.source_not_confirmed": "Source not confirmed",
+  "ui.hub.links.resolve_irreversible": "Confirmation is permanent. A wrong source cannot be changed later; it needs a separate local copy.",
+  "ui.hub.conflict.title": "This changed while you were editing",
+  "ui.hub.conflict.body": "Something else — a configuration run, or another window — wrote to this team after you opened it. Your edits are kept; saving would only ever write the fields you changed, and only from the version you saw. Reload to start from the current one.",
+  "ui.hub.conflict.reload": "Reload the saved version",
+  "ui.hub.status.transport_error": "Couldn't reach the hub. A retry is scheduled.",
+  "ui.hub.links.scope_placeholder": "Choose a scope…",
+  "ui.hub.links.scope_required": "Choose a scope to continue",
+  "ui.hub.links.sources_count": "{count, plural, one {# source} other {# sources}}",
+  "ui.hub.links.links_count": "{count, plural, one {# link} other {# links}}",
+  "ui.hub.links.unresolved_mark": "{item}: source not confirmed. Confirm the source.",
+  "ui.hub.links.mixed": "Mixed",
+  "ui.hub.links.aggregate_mark": "{count, plural, one {# link} other {# links}}; {state}",
+  "ui.hub.links.mark_healthy": "up to date",
+  "ui.hub.links.mark_review": "needs review",
+  "ui.hub.links.mark_failed": "failed",
+  "ui.hub.links.mark_available": "update available",
+  "ui.hub.links.mark_busy": "working",
+  "ui.hub.links.mark_applied": "applied"
+};
+const enUiMesh = {};
+const enUiOnboarding = {
+  "ui.onboarding.connect.intro": "Local Operator needs an AI account to work. Radient is the easiest: one browser sign-in and nothing to paste. Already pay for ChatGPT or Claude? Sign in with that instead. Anything else is under More providers.",
+  "ui.onboarding.default_model.block.loading_models": "Loading the model list…",
+  "ui.onboarding.default_model.block.pick_a_model": "Pick a model to continue.",
+  "ui.onboarding.default_model.change": "Change",
+  "ui.onboarding.default_model.connected_pick": "{brand} is connected. Pick the model new chats should use.",
+  "ui.onboarding.default_model.empty_helper": "No providers are connected yet. Go back a step to connect one.",
+  "ui.onboarding.default_model.fallback_name": "{brand}'s default model",
+  "ui.onboarding.default_model.intro": "New chats use this model. Every agent can pick a different one later.",
+  "ui.onboarding.default_model.loading": "Loading your models",
+  "ui.onboarding.default_model.none_connected": "No provider is connected yet. Go back to connect one, or skip setup and connect one later from the chat.",
+  "ui.onboarding.default_model.nothing_saved": "Nothing will be saved: your Local Operator can't list {brand} models yet, so setup finishes without a default model. Pick one in Settings before your first message.",
+  "ui.onboarding.default_model.provider_fallback": "this provider's",
+  "ui.onboarding.default_model.tag.applied": "your default",
+  "ui.onboarding.default_model.tag.suggested": "suggested for your account",
+  "ui.onboarding.dialog.setup": "Setup",
+  "ui.onboarding.extras.greeting_done": "{name} is your chief of staff. Her conversation is where you pick up with her, and it is one keystroke away in the sidebar. You can also skip straight to a new chat.",
+  "ui.onboarding.extras.greeting_owed": "{name} is your chief of staff. She will say hello first, ask what to call you and what you would like help with, and show you around. You can also skip straight to a new chat.",
+  "ui.onboarding.extras.next_meet": "Next: meet {name}",
+  "ui.onboarding.modal.action.back": "Back",
+  "ui.onboarding.modal.action.continue": "Continue",
+  "ui.onboarding.modal.action.finish": "Finish",
+  "ui.onboarding.modal.action.meet": "Meet {name}",
+  "ui.onboarding.modal.action.skip": "Skip",
+  "ui.onboarding.modal.action.skip_for_now": "Skip for now",
+  "ui.onboarding.modal.action.skip_to_chat": "Skip to chat",
+  "ui.onboarding.modal.error.aida_open_failed": "{name}'s conversation could not be opened, so you are in a new chat instead.",
+  "ui.onboarding.modal.title.connect_provider": "Connect an AI account",
+  "ui.onboarding.modal.title.default_model": "Your default model",
+  "ui.onboarding.modal.title.extras": "Web search (optional)",
+  "ui.onboarding.modal.title.extras_with_name": "Web search, then meet {name}",
+  "ui.onboarding.modal.title.fallback": "First-time setup",
+  "ui.onboarding.search.each_key_saved": "Each key is saved on your device as soon as you leave its field.",
+  "ui.onboarding.search.intro": "Agents can look things up while they work — today's prices, this week's news — instead of relying on what the model already knows.",
+  "ui.onboarding.search.mode.free": "Free",
+  "ui.onboarding.search.mode.free_detail": "Uses a rotating pool of free providers — DuckDuckGo, Tavily's free tier, Exa and Parallel. No key needed; the pool is shared, so searches can be slower at busy times.",
+  "ui.onboarding.search.mode.keys": "Add API keys",
+  "ui.onboarding.search.mode.keys_detail": "Bring your own keys for the search providers you use.",
+  "ui.onboarding.search.mode.label": "Search setup",
+  "ui.onboarding.search.recommended": "Recommended",
+  "ui.onboarding.search.row.get_your": "Get your {name}",
+  "ui.onboarding.search.row.not_saved": "Not saved — {message}",
+  "ui.onboarding.search.row.placeholder": "Paste your API key",
+  "ui.onboarding.search.row.save_failed": "The key could not be saved.",
+  "ui.onboarding.search.row.saved": "Saved",
+  "ui.onboarding.search.row.saving": "Saving {name}",
+  "ui.onboarding.modal.step_of": "Step {current, number} of {total, number}",
+  "ui.onboarding.modal.steps_total": "{total, plural, one {# step} other {# steps}}"
+};
+const enUiProjects = {};
+const enUiProviders = {
+  "ui.providers.phone.account": "Account: {identity}, credential {id}",
+  "ui.providers.phone.account_unlabeled": "Account: credential {id}",
+  "ui.providers.phone.action.activate": "Activate for USD {amount} a month",
+  "ui.providers.phone.action.cancel": "Cancel",
+  "ui.providers.phone.action.check_again": "Check again",
+  "ui.providers.phone.action.choose": "{identity}, credential {id}",
+  "ui.providers.phone.action.choose_unlabeled": "Credential {id}",
+  "ui.providers.phone.action.copy_address": "Copy address",
+  "ui.providers.phone.action.set_up": "Set up phone access",
+  "ui.providers.phone.action.sign_in": "Continue in browser",
+  "ui.providers.phone.address_label": "Phone address",
+  "ui.providers.phone.choose_heading": "Choose an account",
+  "ui.providers.phone.consent": "Activating sets up this Radient account’s tunnel subscription at USD {amount} a month, reserves your phone address and starts the background connector. It does not purchase credit.",
+  "ui.providers.phone.failure.check": "Phone access could not be checked, and nothing was changed.",
+  "ui.providers.phone.failure.run": "Phone access setup could not finish. Steps already completed are not undone. Check again before retrying.",
+  "ui.providers.phone.heading": "Phone access",
+  "ui.providers.phone.outcome.billing_activated_status": "Billing: subscription activation completed; this has not been undone.",
+  "ui.providers.phone.outcome.billing_already_active": "Billing: the subscription was already active.",
+  "ui.providers.phone.outcome.billing_not_activated": "Billing: the current subscription still needs activation.",
+  "ui.providers.phone.outcome.billing_unconfirmed": "Billing: activation was requested but its outcome is unconfirmed. Check the account before retrying; do not assume rollback.",
+  "ui.providers.phone.outcome.failure_stage": "Did not finish: {stage}.",
+  "ui.providers.phone.outcome.reservation_existing": "Phone address: existing reservation retained.",
+  "ui.providers.phone.outcome.reservation_saved": "Phone address: reservation saved on this computer; retry reuses it.",
+  "ui.providers.phone.outcome.reservation_unconfirmed": "Phone address: reservation outcome unconfirmed; retry uses the saved request key.",
+  "ui.providers.phone.outcome.stage_billing": "subscription activation",
+  "ui.providers.phone.outcome.stage_configuration": "existing-route configuration",
+  "ui.providers.phone.outcome.stage_installation": "background connector installation",
+  "ui.providers.phone.outcome.stage_prerequisites": "prerequisite checks",
+  "ui.providers.phone.outcome.stage_reservation": "phone-address reservation",
+  "ui.providers.phone.outcome.stage_verification": "connection verification",
+  "ui.providers.phone.progress_heading": "Setup progress",
+  "ui.providers.phone.receipts_heading": "Completed so far",
+  "ui.providers.phone.signing_in": "Finish signing in in your browser. This updates on its own when you are done.",
+  "ui.providers.phone.status.applying": "Setting up",
+  "ui.providers.phone.status.checking": "Checking",
+  "ui.providers.phone.status.connected": "Connected",
+  "ui.providers.phone.use_address": "Open the URL above and sign in with the same Radient account."
+};
+const enUiSchedules = {};
+const enUiSettings = {
+  "ui.settings.language.dialog.description": "Applies across the app and the terminal — the same setting the settings page edits.",
+  "ui.settings.language.dialog.loading": "Loading the current setting...",
+  "ui.settings.language.dialog.retry": "Retry",
+  "ui.settings.language.dialog.retrying": "Retrying",
+  "ui.settings.language.dialog.save": "Save",
+  "ui.settings.language.dialog.saved": "Saved",
+  "ui.settings.language.dialog.title": "Interface language",
+  "ui.settings.language.dialog.unavailable": "The connected service does not serve the settings this dialog edits.",
+  "ui.settings.language.effective": "In effect: {locale}",
+  "ui.settings.language.external_notice": "Interface language changed elsewhere — now {language}.",
+  "ui.settings.language.general.description": "Choose the language shared by the app and terminal. Changes save immediately; existing conversations are not rewritten.",
+  "ui.settings.language.general.effective": "App language in effect: {locale}",
+  "ui.settings.language.general.last_known": "Last synced app language: {locale}",
+  "ui.settings.language.general.no_resolution": "The app language has not been set yet.",
+  "ui.settings.language.general.pending": "Saving language…",
+  "ui.settings.language.general.readback_error": "The write was confirmed, but the current setting could not be checked. Reconnect or retry before changing it again.",
+  "ui.settings.language.general.saved": "Language saved.",
+  "ui.settings.language.general.system": "Use system",
+  "ui.settings.language.general.unavailable_choice": "Not available",
+  "ui.settings.language.general.write_error": "The language was not saved. Your previous setting is unchanged. {message}",
+  "ui.settings.language.palette_action": "Change interface language",
+  "ui.settings.page.title": "Settings",
+  "ui.settings.profile.description_anonymous": "Your user profile information displayed in the application. This information is not provided to the agents.",
+  "ui.settings.profile.description_authenticated": "Your user profile information displayed in the application. This information is not provided to the agents. These details are provided through your Radient account.",
+  "ui.settings.profile.display_name.label": "Display name",
+  "ui.settings.profile.display_name.placeholder": "Enter your name...",
+  "ui.settings.profile.email.label": "Email address",
+  "ui.settings.profile.email.placeholder": "Enter your email...",
+  "ui.settings.profile.title": "User profile",
+  "ui.settings.section.interface_language.help": "Interface language, one setting shared with the terminal. auto follows your operating system, falling back to English.",
+  "ui.settings.section.interface_language.label": "Interface language",
+  "ui.settings.tour.action": "Take the tour",
+  "ui.settings.tour.description": "Missed the application onboarding tour or want a refresher? Start it again here.",
+  "ui.settings.tour.title": "Application tour",
+  "ui.settings.profile.account_checking": "Checking your Radient account…",
+  "ui.settings.profile.account_read_failed_retry": "Your Radient account could not be read, so the name and email below are placeholders rather than your account details. Retry.",
+  "ui.settings.profile.account_read_failed_refused": "Your Radient account could not be read, so the name and email below are placeholders rather than your account details. Retry, or sign in to Radient again.",
+  "ui.settings.profile.retry": "Retry",
+  "ui.settings.profile.retrying": "Retrying"
+};
+const enUiShell = {};
+const frUiConsole = {
+  "ui.console.close.body": "Le programme en cours sera arrêté et son onglet supprimé.",
+  "ui.console.close.busy": "Fermeture…",
+  "ui.console.close.confirm": "Fermer le terminal",
+  "ui.console.close.kept": "Sa sortie est conservée.",
+  "ui.console.close.title": "Fermer ce terminal ?",
+  "ui.console.create_failed.detail": "Le service de console fonctionne, mais a refusé de lancer un programme pour cette conversation — c’est donc cet essai qui a échoué, la console n’est pas désactivée. Réessayez d’abord ; si l’échec persiste, la ligne ci-dessous indique le motif fourni par le service.",
+  "ui.console.create_failed.retry": "Réessayer",
+  "ui.console.create_failed.title": "Impossible de démarrer la console dans cette session",
+  "ui.console.empty.detail": "Une console exécute un programme dans le dossier de cette conversation et conserve sa sortie, même si ce volet est fermé.",
+  "ui.console.empty.title": "Aucune console dans cette session",
+  "ui.console.ended.exit_code": "code de sortie {code}",
+  "ui.console.ended.exit_unknown": "code de sortie non observé",
+  "ui.console.ended.live": "Ce terminal est terminé",
+  "ui.console.ended.restored": "Ce terminal est terminé, historique restauré",
+  "ui.console.loading.create": "Démarrage d’une console",
+  "ui.console.loading.read": "Lecture de la console de cette session",
+  "ui.console.new": "Nouvelle console",
+  "ui.console.pane.blip": "Terminé depuis votre dernière visite",
+  "ui.console.pane.close": "Fermer la console",
+  "ui.console.pane.close_refusal": "Le terminal n’a pas pu être fermé.",
+  "ui.console.pane.label": "Console",
+  "ui.console.pane.needs_conversation.detail": "Une console utilise le dossier de travail d’une conversation : sans conversation, elle ne peut pas être créée.",
+  "ui.console.pane.needs_conversation.title": "La console nécessite une conversation",
+  "ui.console.pane.surfaces": "Terminaux de la console",
+  "ui.console.secure": "Saisie sécurisée activée : ce que vous tapez ici n’est pas enregistré.",
+  "ui.console.unavailable.disabled.detail": "LOCAL_OPERATOR_UI_CONSOLE_HOST vaut 0 dans l’environnement de l’application : aucun terminal n’est lancé et aucune surface ne peut être créée. Supprimez cette variable pour réactiver la console.",
+  "ui.console.unavailable.disabled.title": "La console est désactivée pour cette exécution",
+  "ui.console.unavailable.pty.detail": "La prise en charge des terminaux n’a pas été chargée pour cette exécution. Une mise à jour de Local Operator la rétablit ; le journal de l’application indique la cause.",
+  "ui.console.unavailable.title": "La console est indisponible dans cette application",
+  "ui.console.unavailable.unknown.detail": "Cette fenêtre n’a pas pu accéder à la console et n’a pas indiqué pourquoi. Le journal de l’application précise la cause.",
+  "ui.console.capacity.summary": "{live, number} sur {limit, number} actifs dans l’app",
+  "ui.console.capacity.summary_compact": "{live, number}/{limit, number} · {archived, plural, one {# gardé} many {# de gardés} other {# gardés}}",
+  "ui.console.capacity.summary_compact_bare": "{live, number}/{limit, number}",
+  "ui.console.capacity.archived": " · {archived, plural, one {# gardé} many {# de gardés} other {# gardés}}",
+  "ui.console.capacity.full": " · plein",
+  "ui.console.capacity.help": "Compteurs pour toute l’application, toutes conversations confondues. L’historique conservé n’occupe pas d’emplacement de processus.",
+  "ui.console.capacity.resources": "Stockage géré estimé : {memory, number} MiB. Journaux : {logs, number} MiB. Sortie en attente : {pending, number} MiB. Cellules de terminal : {cells, number}. Terminaux protégés : {protected, number}. La mémoire des processus enfants n’est pas incluse.",
+  "ui.console.cleanup.label": "Effacer les terminaux d’agent terminés",
+  "ui.console.cleanup.help": "Efface les terminaux d’agent terminés de cette conversation. Ceux que l’agent a demandé de conserver restent sur le disque ; les autres sont fermés et leur sortie n’est pas conservée. Les terminaux que vous avez ouverts, ainsi que ceux en cours d’utilisation, ne sont pas touchés.",
+  "ui.console.cleanup.result": "Effacé : {released, plural, one {# terminal d’agent terminé} many {# de terminaux d’agent terminés} other {# terminaux d’agent terminés}}. {protected, plural, =0 {} one {# terminal est encore utilisé et a été laissé ouvert.} many {# de terminaux sont encore utilisés et ont été laissés ouverts.} other {# terminaux sont encore utilisés et ont été laissés ouverts.}}",
+  "ui.console.cleanup.result_none": "Rien à effacer — aucun terminal d’agent terminé dans cette conversation.",
+  "ui.console.dismiss_history": "Effacer le terminal et supprimer la sortie conservée",
+  "ui.console.dismiss.body": "Effacer ce terminal supprime sa sortie conservée sur le disque ; une relance ne pourra pas la restaurer.",
+  "ui.console.dismiss.title": "Effacer ce terminal ?",
+  "ui.console.dismiss.confirm": "Effacer le terminal",
+  "ui.console.tab.ended": "terminé",
+  "ui.console.tab.agent_opened": "Un agent a ouvert cette console",
+  "ui.console.tab.agent_typed": "Un agent a saisi du texte dans cette console",
+  "ui.console.tab.close_label": "Fermer {title}, onglet {index, number} sur {total, number}",
+  "ui.console.tab.clear_label": "Effacer {title}, onglet {index, number} sur {total, number}",
+  "ui.console.tab.clear_label_retained": "Effacer {title}, onglet {index, number} sur {total, number} — supprime la sortie conservée",
+  "ui.console.secure_toggle.stop": "Arrêter la saisie sécurisée",
+  "ui.console.secure_toggle.start": "Saisie sécurisée",
+  "ui.console.secure_toggle.start_tooltip": "Saisie sécurisée : arrêter l’enregistrement de ce terminal",
+  "ui.console.close.cancel": "Annuler",
+  "ui.console.terminal.prompt_label": "Saisie du terminal",
+  "ui.console.terminal.too_much_output": "Trop de sortie à annoncer, parcourez les lignes manuellement pour les lire"
+};
+const frUiOnboarding = {
+  "ui.onboarding.connect.intro": "Local Operator a besoin d’un compte IA pour fonctionner. Radient est le plus simple : une connexion dans le navigateur, rien à coller. Vous payez déjà pour ChatGPT ou Claude ? Connectez-vous avec ce compte. Les autres options sont regroupées plus bas.",
+  "ui.onboarding.default_model.block.loading_models": "Chargement des modèles…",
+  "ui.onboarding.default_model.block.pick_a_model": "Choisissez un modèle pour continuer.",
+  "ui.onboarding.default_model.change": "Modifier",
+  "ui.onboarding.default_model.connected_pick": "{brand} est connecté. Choisissez le modèle des nouvelles conversations.",
+  "ui.onboarding.default_model.empty_helper": "Aucun fournisseur connecté. Revenez à l’étape précédente pour en connecter un.",
+  "ui.onboarding.default_model.fallback_name": "Modèle par défaut — {brand}",
+  "ui.onboarding.default_model.intro": "Ce modèle servira aux nouvelles conversations. Chaque agent pourra en changer.",
+  "ui.onboarding.default_model.loading": "Chargement de vos modèles",
+  "ui.onboarding.default_model.none_connected": "Aucun fournisseur n’est encore connecté. Revenez en arrière pour en connecter un, ou passez la configuration et connectez-en un plus tard depuis la conversation.",
+  "ui.onboarding.default_model.nothing_saved": "Rien ne sera enregistré : Local Operator ne peut pas encore lister les modèles proposés par {brand}. La configuration se termine donc sans modèle par défaut. Choisissez-en un dans Paramètres avant votre premier message.",
+  "ui.onboarding.default_model.provider_fallback": "ce fournisseur",
+  "ui.onboarding.default_model.tag.applied": "votre modèle par défaut",
+  "ui.onboarding.default_model.tag.suggested": "suggéré pour votre compte",
+  "ui.onboarding.dialog.setup": "Configuration",
+  "ui.onboarding.extras.greeting_done": "{name} est votre cheffe de cabinet. Retrouvez-la dans sa conversation, accessible en une touche depuis la barre latérale. Vous pouvez aussi passer directement à une nouvelle conversation.",
+  "ui.onboarding.extras.greeting_owed": "{name} est votre cheffe de cabinet. Elle vous accueillera, vous demandera comment vous appeler et en quoi vous aider, puis vous fera une visite guidée. Vous pouvez aussi passer directement à une nouvelle conversation.",
+  "ui.onboarding.extras.next_meet": "Ensuite : rencontrer {name}",
+  "ui.onboarding.modal.action.back": "Retour",
+  "ui.onboarding.modal.action.continue": "Continuer",
+  "ui.onboarding.modal.action.finish": "Terminer",
+  "ui.onboarding.modal.action.meet": "Rencontrer {name}",
+  "ui.onboarding.modal.action.skip": "Passer",
+  "ui.onboarding.modal.action.skip_for_now": "Plus tard",
+  "ui.onboarding.modal.action.skip_to_chat": "Passer à la conversation",
+  "ui.onboarding.modal.error.aida_open_failed": "Impossible d’ouvrir la conversation avec {name} ; une nouvelle conversation a été ouverte à la place.",
+  "ui.onboarding.modal.title.connect_provider": "Connecter un compte IA",
+  "ui.onboarding.modal.title.default_model": "Votre modèle par défaut",
+  "ui.onboarding.modal.title.extras": "Recherche web (facultative)",
+  "ui.onboarding.modal.title.extras_with_name": "Recherche web, puis rencontre avec {name}",
+  "ui.onboarding.modal.title.fallback": "Configuration initiale",
+  "ui.onboarding.search.each_key_saved": "Chaque clé est enregistrée sur votre appareil dès que vous quittez son champ.",
+  "ui.onboarding.search.intro": "Les agents peuvent chercher des informations pendant leur travail — prix du jour, actualités de la semaine — plutôt que de se limiter aux connaissances du modèle.",
+  "ui.onboarding.search.mode.free": "Gratuit",
+  "ui.onboarding.search.mode.free_detail": "Utilise à tour de rôle des fournisseurs gratuits — DuckDuckGo, l’offre gratuite de Tavily, Exa et Parallel. Aucune clé nécessaire ; l’accès est partagé, les recherches peuvent donc ralentir aux heures de pointe.",
+  "ui.onboarding.search.mode.keys": "Ajouter des clés API",
+  "ui.onboarding.search.mode.keys_detail": "Utilisez vos propres clés pour vos fournisseurs de recherche.",
+  "ui.onboarding.search.mode.label": "Mode de recherche",
+  "ui.onboarding.search.recommended": "Recommandé",
+  "ui.onboarding.search.row.get_your": "Obtenir {name}",
+  "ui.onboarding.search.row.not_saved": "Non enregistré — {message}",
+  "ui.onboarding.search.row.placeholder": "Collez votre clé API",
+  "ui.onboarding.search.row.save_failed": "La clé n’a pas pu être enregistrée.",
+  "ui.onboarding.search.row.saved": "Enregistré",
+  "ui.onboarding.search.row.saving": "Enregistrement : {name}",
+  "ui.onboarding.modal.step_of": "Étape {current, number} sur {total, number}",
+  "ui.onboarding.modal.steps_total": "{total, plural, one {# étape} many {# d’étapes} other {# étapes}}"
+};
+const frUiSettings = {
+  "ui.settings.language.dialog.description": "S’applique à l’application et au terminal — le même réglage que dans les paramètres.",
+  "ui.settings.language.dialog.loading": "Chargement du réglage actuel…",
+  "ui.settings.language.dialog.retry": "Réessayer",
+  "ui.settings.language.dialog.retrying": "Nouvel essai",
+  "ui.settings.language.dialog.save": "Enregistrer",
+  "ui.settings.language.dialog.saved": "Enregistré",
+  "ui.settings.language.dialog.title": "Langue de l’interface",
+  "ui.settings.language.dialog.unavailable": "Le service connecté ne fournit pas les paramètres modifiés dans cette fenêtre.",
+  "ui.settings.language.effective": "Langue utilisée : {locale}",
+  "ui.settings.language.external_notice": "Langue de l’interface modifiée ailleurs — désormais {language}.",
+  "ui.settings.language.general.description": "Choisissez la langue de l’application et du terminal. Enregistrement immédiat ; les conversations existantes restent inchangées.",
+  "ui.settings.language.general.effective": "Langue de l’application utilisée : {locale}",
+  "ui.settings.language.general.last_known": "Dernière langue de l’application synchronisée : {locale}",
+  "ui.settings.language.general.no_resolution": "La langue de l’application n’est pas encore définie.",
+  "ui.settings.language.general.pending": "Enregistrement de la langue…",
+  "ui.settings.language.general.readback_error": "L’enregistrement est confirmé, mais le réglage actuel n’a pas pu être vérifié. Rétablissez la connexion ou réessayez avant de le modifier.",
+  "ui.settings.language.general.saved": "Langue enregistrée.",
+  "ui.settings.language.general.system": "Langue du système",
+  "ui.settings.language.general.unavailable_choice": "Indisponible",
+  "ui.settings.language.general.write_error": "La langue n’a pas été enregistrée. Le réglage précédent reste inchangé. {message}",
+  "ui.settings.language.palette_action": "Changer la langue de l’interface",
+  "ui.settings.page.title": "Paramètres",
+  "ui.settings.profile.description_anonymous": "Les informations de votre profil affichées dans l’application ne sont pas transmises aux agents.",
+  "ui.settings.profile.description_authenticated": "Les informations de votre profil affichées dans l’application ne sont pas transmises aux agents. Elles proviennent de votre compte Radient.",
+  "ui.settings.profile.display_name.label": "Nom affiché",
+  "ui.settings.profile.display_name.placeholder": "Saisissez votre nom…",
+  "ui.settings.profile.email.label": "Adresse e-mail",
+  "ui.settings.profile.email.placeholder": "Saisissez votre e-mail…",
+  "ui.settings.profile.title": "Profil utilisateur",
+  "ui.settings.section.interface_language.help": "Langue de l’interface, partagée avec le terminal. auto suit la langue du système ou utilise l’anglais à défaut.",
+  "ui.settings.section.interface_language.label": "Langue de l’interface",
+  "ui.settings.tour.action": "Lancer la visite",
+  "ui.settings.tour.description": "Vous avez manqué la visite guidée ou souhaitez la revoir ? Relancez-la ici.",
+  "ui.settings.tour.title": "Visite guidée",
+  "ui.settings.profile.account_checking": "Vérification de votre compte Radient…",
+  "ui.settings.profile.account_read_failed_retry": "Votre compte Radient n’a pas pu être lu ; le nom et l’adresse e-mail ci-dessous sont donc des valeurs par défaut, et non les informations de votre compte. Réessayez.",
+  "ui.settings.profile.account_read_failed_refused": "Votre compte Radient n’a pas pu être lu ; le nom et l’adresse e-mail ci-dessous sont donc des valeurs par défaut, et non les informations de votre compte. Réessayez, ou reconnectez-vous à Radient.",
+  "ui.settings.profile.retry": "Réessayer",
+  "ui.settings.profile.retrying": "Nouvel essai"
+};
+const bundledEnglish = {
+  ...enUiAgents,
+  ...enUiBrowserChrome,
+  ...enUiBrowser,
+  ...enUiCanvas,
+  ...enUiChat,
+  ...enUiConsole,
+  ...enUiHub,
+  ...enUiMesh,
+  ...enUiOnboarding,
+  ...enUiProjects,
+  ...enUiProviders,
+  ...enUiSchedules,
+  ...enUiSettings,
+  ...enUiShell
+};
+const bundledCatalogues = {
+  en: bundledEnglish,
+  fr: {
+    ...frUiConsole,
+    ...frUiOnboarding,
+    ...frUiSettings
+  }
+};
+const DEFAULT_LOCALE = "en";
+function deviceLanguage() {
+  const navigatorLike = globalThis.navigator;
+  const language = navigatorLike?.language;
+  return typeof language === "string" && language.trim() !== "" ? language : void 0;
+}
+function resolveLocale(capabilities) {
+  const device = deviceLanguage();
+  return device ? { locale: device, source: "device" } : { locale: DEFAULT_LOCALE, source: "default" };
+}
+let state = resolveLocale();
+function currentLocale() {
+  return state.locale;
+}
+const registered = /* @__PURE__ */ new Map();
+function messageFor(key, locale) {
+  const served = registered.get(locale)?.[key];
+  if (served !== void 0) return served;
+  const bundled = bundledCatalogues[locale]?.[key];
+  if (bundled !== void 0) return bundled;
+  return bundledEnglish[key];
+}
+function sourceTagFor(key, locale) {
+  if (registered.get(locale)?.[key] !== void 0) return locale;
+  if (bundledCatalogues[locale]?.[key] !== void 0) return locale;
+  return DEFAULT_LOCALE;
+}
+const formats = /* @__PURE__ */ new Map();
+function formatterFor(locale, message) {
+  const cacheKey = `${locale}\0${message}`;
+  let format = formats.get(cacheKey);
+  if (format === void 0) {
+    format = new IntlMessageFormat(message, locale);
+    formats.set(cacheKey, format);
+  }
+  return format;
+}
+function translate(key, params = {}, locale = currentLocale()) {
+  const message = messageFor(key, locale);
+  if (message === void 0) return key;
+  const tag = sourceTagFor(key, locale);
+  try {
+    const rendered = formatterFor(tag, message).format(params);
+    return typeof rendered === "string" ? rendered : String(rendered);
+  } catch {
+    return key;
+  }
+}
+function t(key, params) {
+  return translate(key, params ?? {});
+}
 function requesterOf(params, requestId2) {
   const supplied = typeof params.requester === "string" ? params.requester.trim() : "";
   return supplied.startsWith("session:") ? supplied : requestId2;
@@ -31328,6 +34826,35 @@ function factOf(path2) {
     sha256: ""
   };
 }
+class ChromeTabOrder {
+  ids = [];
+  customized = false;
+  get hasCustomOrder() {
+    return this.customized;
+  }
+  project(records) {
+    if (!this.customized) this.ids = records.map((record) => record.tabId);
+    const byId = new Map(records.map((record) => [record.tabId, record]));
+    this.ids = this.ids.filter((id2) => byId.has(id2));
+    const known = new Set(this.ids);
+    this.ids.push(
+      ...records.filter((r) => !known.has(r.tabId)).map((r) => r.tabId)
+    );
+    return this.ids.map((id2) => byId.get(id2)).filter((record) => record !== void 0);
+  }
+  reorder(records, permutation) {
+    this.project(records);
+    const selected = new Set(permutation);
+    if (selected.size !== permutation.length || [...permutation].some((id2) => !this.ids.includes(id2)))
+      return false;
+    this.customized = true;
+    let index = 0;
+    this.ids = this.ids.map(
+      (id2) => selected.has(id2) ? permutation[index++] : id2
+    );
+    return true;
+  }
+}
 const PAGE_ZOOM_STEPS = [
   0.25,
   0.33,
@@ -31490,6 +35017,7 @@ class PageControls {
     if (changed) this.changed();
   }
 }
+const DUPLICATABLE_WEB_URL = /^https?:\/\//i;
 const DOCUMENT_SCOPED = /* @__PURE__ */ new Set([
   "read",
   // The structured reads (`styles`, `hit_test`, `ancestors`) describe the
@@ -31575,6 +35103,7 @@ function sessionRequesterOf(requester) {
   return id2 || null;
 }
 class BrowserHost {
+  chromeTabOrder = new ChromeTabOrder();
   registry;
   pageControls;
   cdp;
@@ -31888,7 +35417,8 @@ class BrowserHost {
     const navigation = active?.view.webContents.navigationHistory;
     return {
       pageControls: this.pageControls.state(active),
-      tabs: this.registry.snapshot().map((entry) => ({
+      tabs: this.chromeTabOrder.project(this.registry.snapshot()).map((entry, displayOrder) => ({
+        ...this.chromeTabOrder.hasCustomOrder ? { displayOrder } : {},
         tabId: entry.tabId,
         title: this.titleForChrome(entry.title) || "New tab",
         url: entry.url,
@@ -32008,14 +35538,75 @@ class BrowserHost {
     await this.createUserTab(sessionId2 ?? null);
     return this.chromeState();
   }
+  /** Human duplicates copy URL ONLY. Session attribution is not a capability,
+   * but copying it would still put an agent's duplicate inside its conversation.
+   * User records have no nonce/handover; an explicit later handover is the only
+   * way they can become agent-drivable. Failure retains that plain user tab. */
+  async actOnChromeTab(tabId, action) {
+    const record = this.registry.get(tabId);
+    if (!record || record.view.webContents.isDestroyed())
+      return {
+        status: "failed",
+        action,
+        tabId: null,
+        error: { code: "tab_closed", message: t("ui.browser.chrome.tab_gone") }
+      };
+    let url = "";
+    let destinationId = action === "reload" ? tabId : null;
+    try {
+      url = record.view.webContents.getURL();
+      if (action === "duplicate" && url !== "about:blank" && !DUPLICATABLE_WEB_URL.test(url))
+        return {
+          status: "failed",
+          action,
+          tabId: null,
+          error: {
+            code: "unsupported_page",
+            message: t("ui.browser.chrome.duplicate_refused")
+          }
+        };
+      if (action === "reload") record.view.webContents.reload();
+      else {
+        const copy = await this.createUserTab(null, url, (created) => {
+          destinationId = created.tabId;
+        });
+        destinationId = copy.tabId;
+      }
+      this.onChanged();
+      return { status: "completed", action, tabId: destinationId };
+    } catch {
+      if (destinationId !== null && action === "duplicate")
+        this.recordLoadFailure(destinationId, {
+          code: -2,
+          description: "DUPLICATE_NAVIGATION_FAILED",
+          url
+        });
+      return {
+        status: "failed",
+        action,
+        tabId: destinationId,
+        error: {
+          code: "navigation_failed",
+          message: t("ui.browser.chrome.operation_failed", { action })
+        }
+      };
+    }
+  }
+  reorderChromeTabs(ids) {
+    if (!this.chromeTabOrder.reorder(this.registry.snapshot(), ids))
+      throw new Error(t("ui.browser.chrome.invalid_order"));
+    this.onChanged();
+    return this.chromeState();
+  }
   /** `newTab`'s body, returning the record so `reopenClosed` can navigate the tab
    * it created rather than whichever tab is active by the time the await ends. */
-  async createUserTab(sessionId2) {
+  async createUserTab(sessionId2, initialUrl = "about:blank", onCreated) {
     const record = this.registry.create({
       owner: "user",
       sessionId: sessionId2
     });
-    await record.view.webContents.loadURL("about:blank");
+    onCreated?.(record);
+    await record.view.webContents.loadURL(initialUrl);
     await this.cdp.attach(record.view.webContents);
     this.onChanged();
     return record;
@@ -32610,12 +36201,12 @@ class ConsentNotifier {
     this.announced = count;
     if (!increased) return;
     if (this.options.show !== "focus") return;
-    const create = this.options.createNotification;
-    if (!create && !electron.Notification.isSupported()) return;
+    const create2 = this.options.createNotification;
+    if (!create2 && !electron.Notification.isSupported()) return;
     const oldest = pending[0];
     if (!oldest) return;
     try {
-      const notification = (create ?? ((options) => new electron.Notification(options)))(
+      const notification = (create2 ?? ((options) => new electron.Notification(options)))(
         {
           title: CONSENT_TITLE,
           body: consentBody(count, oldest.origin),
@@ -32967,19 +36558,19 @@ class DownloadArmer {
       }
       this.showProgress(capture, entry);
     });
-    item.once("done", (_event, state) => {
+    item.once("done", (_event, state2) => {
       capture.pending -= 1;
       capture.live = capture.live.filter((live) => live !== entry);
       const name = path$1.basename(savePath);
       this.release(capture, savePath);
       if (entry.weCancelled) {
-        if (state !== "completed") discardPartial(savePath, this.options.log);
-      } else if (state === "completed") {
+        if (state2 !== "completed") discardPartial(savePath, this.options.log);
+      } else if (state2 === "completed") {
         restrictMode(savePath, this.options.log);
         capture.files.push(fileFact(item, savePath));
         this.note(capture, name, "saved", 1, "", null);
       } else {
-        const reason = capture.settled ? `refused: \`${name}\` did not finish (${state}) after this call's answer; the partial file was discarded` : `refused: \`${name}\` did not finish (${state}); the partial file was discarded`;
+        const reason = capture.settled ? `refused: \`${name}\` did not finish (${state2}) after this call's answer; the partial file was discarded` : `refused: \`${name}\` did not finish (${state2}); the partial file was discarded`;
         discardPartial(savePath, this.options.log);
         if (!capture.settled) capture.refusals.push(reason);
         this.note(capture, name, "refused", 1, reason, {
@@ -33329,6 +36920,8 @@ const BROWSER_IPC_CHANNELS = [
   "browser-reopen-tab",
   "browser-focus-page",
   "browser-new-tab",
+  "browser-reorder-tabs",
+  "browser-tab-action",
   "browser-close-tab",
   "browser-close-tabs",
   "browser-activate-tab",
@@ -33398,6 +36991,23 @@ function registerBrowserIpc(options) {
     const host = authorize(event);
     return host.newTab(optionalConversationOrThrow(sessionId2));
   });
+  electron.ipcMain.handle("browser-reorder-tabs", (event, ids) => {
+    const host = authorize(event);
+    if (!Array.isArray(ids) || ids.length > 512 || Array.from(ids).some(
+      (id2) => typeof id2 !== "number" || !Number.isSafeInteger(id2) || id2 < 0
+    ))
+      throw new Error(t("ui.browser.chrome.invalid_order"));
+    return host.reorderChromeTabs(ids);
+  });
+  electron.ipcMain.handle(
+    "browser-tab-action",
+    (event, tabId, action) => {
+      const host = authorize(event);
+      if (action !== "duplicate" && action !== "reload")
+        throw new Error(t("ui.browser.chrome.invalid_action"));
+      return host.actOnChromeTab(numberOrThrow(tabId, "tabId"), action);
+    }
+  );
   electron.ipcMain.handle("browser-close-tab", (event, tabId) => {
     const host = authorize(event);
     return host.closeTab(numberOrThrow(tabId, "tabId"));
@@ -33654,10 +37264,10 @@ class OwnershipLedger {
   }
   /** The scope a proof names, after the session and generation checks. Creation
    * is opt-in per method, matching the extension's `create` flag. */
-  mutate(params, fn, create = false) {
+  mutate(params, fn, create2 = false) {
     const [proof, session, generation] = this.identity(params);
     let scope = this.scopes.get(proof);
-    if (!scope && create) {
+    if (!scope && create2) {
       scope = {
         session,
         generation,
@@ -33675,7 +37285,7 @@ class OwnershipLedger {
     return fn(scope);
   }
   /** Record (or clear) the tab an allocation owns. */
-  recordAllocation(params, tab, state) {
+  recordAllocation(params, tab, state2) {
     if (!params.owner_proof) return;
     this.mutate(params, (scope) => {
       const allocation = String(params.allocation_id ?? "");
@@ -33685,7 +37295,7 @@ class OwnershipLedger {
       if (scope.terminal) {
         throw new BridgeCommandError("owner_refused", "browser scope ended");
       }
-      scope.allocations[allocation] = { tab: tab || void 0, state };
+      scope.allocations[allocation] = { tab: tab || void 0, state: state2 };
     });
   }
   /**
@@ -36645,10 +40255,10 @@ class DesktopNotifier {
    * being left.
    */
   releaseWatch(windowId, sessionId2) {
-    const state = this.windows.get(windowId);
-    if (!state) return;
-    if (!sessionId2 || state.session !== sessionId2) return;
-    this.windows.set(windowId, { ...state, session: "" });
+    const state2 = this.windows.get(windowId);
+    if (!state2) return;
+    if (!sessionId2 || state2.session !== sessionId2) return;
+    this.windows.set(windowId, { ...state2, session: "" });
   }
   /**
    * Called by the stream relay for every parsed frame it forwards, and by the
@@ -36844,11 +40454,11 @@ class DesktopNotifier {
    * suppresses every completion for the life of the process.
    */
   anyDisplayingFocused(sessionId2) {
-    for (const [id2, state] of this.windows) {
-      if (!state.visible || !state.focused) continue;
-      if (state.session !== sessionId2) continue;
+    for (const [id2, state2] of this.windows) {
+      if (!state2.visible || !state2.focused) continue;
+      if (state2.session !== sessionId2) continue;
       if (!this.host.windowAlive(id2)) continue;
-      if (Date.now() - state.seenAt > RENDERER_REPORT_TTL_MS) continue;
+      if (Date.now() - state2.seenAt > RENDERER_REPORT_TTL_MS) continue;
       return true;
     }
     return false;
@@ -45441,7 +49051,7 @@ class ViewerEndpoint {
       }
     });
   }
-  async onLine(line, socket, state) {
+  async onLine(line, socket, state2) {
     let frame;
     try {
       frame = JSON.parse(line);
@@ -45450,13 +49060,13 @@ class ViewerEndpoint {
     }
     if (typeof frame !== "object" || frame === null) return;
     const record = frame;
-    if (!state.isAuthenticated()) {
+    if (!state2.isAuthenticated()) {
       const key = typeof record.key === "string" ? record.key : "";
       if (!constantTimeEqual(key, this.key)) {
-        state.finish();
+        state2.finish();
         return;
       }
-      state.markAuthenticated();
+      state2.markAuthenticated();
       return;
     }
     const op = typeof record.op === "string" ? record.op : "";
@@ -45475,7 +49085,7 @@ class ViewerEndpoint {
       socket.write(`${JSON.stringify(reply)}
 `);
     } catch {
-      state.finish();
+      state2.finish();
     }
   }
   async apply(op, frame) {
@@ -46021,8 +49631,8 @@ function frameNavigationVerdict(input, trustedRendererUrls) {
     }
     const own = trustedRendererUrls.some((trusted) => {
       try {
-        const t = new URL(trusted);
-        return t.protocol === "file:" ? minted.protocol === "file:" : minted.origin === t.origin;
+        const t2 = new URL(trusted);
+        return t2.protocol === "file:" ? minted.protocol === "file:" : minted.origin === t2.origin;
       } catch {
         return false;
       }
@@ -47170,10 +50780,10 @@ electron.app.whenReady().then(async () => {
       if (!window || window.isDestroyed()) return;
       window.webContents.send("desktop-feed-frame", frame);
     },
-    (state) => {
+    (state2) => {
       const window = mainWindow;
       if (!window || window.isDestroyed()) return;
-      window.webContents.send("desktop-feed-state", state);
+      window.webContents.send("desktop-feed-state", state2);
     }
   );
   backendService.providePresenceContext(() => desktopNotifier.presence());
@@ -47299,10 +50909,10 @@ electron.app.whenReady().then(async () => {
        */
       env: launchEnv,
       onTrigger: () => miniView?.toggle(),
-      onState: (state) => {
+      onState: (state2) => {
         for (const window of electron.BrowserWindow.getAllWindows()) {
           if (window.isDestroyed()) continue;
-          window.webContents.send(MINI_VIEW_REGISTRATION, state);
+          window.webContents.send(MINI_VIEW_REGISTRATION, state2);
         }
       }
     });
@@ -47318,10 +50928,10 @@ electron.app.whenReady().then(async () => {
     );
     quickSendWatcher = watchQuickSend({
       onValue: (value) => {
-        const state = miniViewRegistrar?.apply(value);
-        if (state)
+        const state2 = miniViewRegistrar?.apply(value);
+        if (state2)
           logger.info(
-            `mini-view: config changed, registration is ${state.status}`,
+            `mini-view: config changed, registration is ${state2.status}`,
             LogFileType.BACKEND
           );
       },
@@ -47344,9 +50954,9 @@ electron.app.whenReady().then(async () => {
     if (!owner || owner.isDestroyed() || event.sender !== owner.webContents || event.senderFrame !== owner.webContents.mainFrame) {
       throw new Error("This window cannot read the hotkey registration.");
     }
-    const state = miniViewRegistrar?.getState() ?? null;
-    if (state) {
-      return state;
+    const state2 = miniViewRegistrar?.getState() ?? null;
+    if (state2) {
+      return state2;
     }
     return {
       value: "",