@kehto/paja 0.1.0

package/dist/chunk-BM6ROSMJ.js

@@ -0,0 +1,635 @@
+// src/config-file.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+
+// src/simulation.ts
+var PajaSimulationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PajaSimulationError";
+  }
+};
+var PAJA_SIMULATION_DOMAINS = [
+  "relay",
+  "outbox",
+  "storage",
+  "identity",
+  "keys",
+  "config",
+  "resource",
+  "theme",
+  "notify",
+  "media",
+  "upload",
+  "intent",
+  "cvm",
+  "inc"
+];
+var DEFAULT_RELAY_URLS = ["wss://relay.kehto.dev"];
+var DEFAULT_CONFIG_VALUES = {
+  runtime: "kehto paja",
+  mode: "development",
+  target: "single-window"
+};
+var DEFAULT_THEME_VALUES = {
+  title: "Kehto Paja"
+};
+function normalizePajaSimulation(raw) {
+  const domainOverrides = raw?.capabilities?.domains ?? {};
+  const domains = Object.fromEntries(
+    PAJA_SIMULATION_DOMAINS.map((domain) => [domain, domainOverrides[domain] ?? true])
+  );
+  const relayMode = raw?.relay?.mode ?? (domains.relay ? "memory" : "disabled");
+  if (!domains.relay && relayMode !== "disabled") {
+    throw new PajaSimulationError('Invalid simulation: relay.mode must be "disabled" when capabilities.domains.relay is false.');
+  }
+  if (!domains.outbox && relayMode !== "disabled") {
+    throw new PajaSimulationError('Invalid simulation: relay.mode must be "disabled" when capabilities.domains.outbox is false.');
+  }
+  if (relayMode === "disabled") {
+    domains.relay = false;
+    domains.outbox = false;
+  }
+  const uploadMode = raw?.upload?.mode ?? (domains.upload ? "memory" : "disabled");
+  if (!domains.upload && uploadMode !== "disabled") {
+    throw new PajaSimulationError('Invalid simulation: upload.mode must be "disabled" when capabilities.domains.upload is false.');
+  }
+  if (uploadMode === "disabled") domains.upload = false;
+  const intentEnabled = raw?.intent?.enabled ?? domains.intent;
+  if (!domains.intent && intentEnabled) {
+    throw new PajaSimulationError("Invalid simulation: intent.enabled must be false when capabilities.domains.intent is false.");
+  }
+  if (!intentEnabled) domains.intent = false;
+  const mediaEnabled = raw?.media?.enabled ?? domains.media;
+  if (!domains.media && mediaEnabled) {
+    throw new PajaSimulationError("Invalid simulation: media.enabled must be false when capabilities.domains.media is false.");
+  }
+  if (!mediaEnabled) domains.media = false;
+  const cvmEnabled = raw?.cvm?.enabled ?? domains.cvm;
+  if (!domains.cvm && cvmEnabled) {
+    throw new PajaSimulationError("Invalid simulation: cvm.enabled must be false when capabilities.domains.cvm is false.");
+  }
+  if (!cvmEnabled) domains.cvm = false;
+  const notificationsEnabled = raw?.notifications?.enabled ?? domains.notify;
+  if (!domains.notify && notificationsEnabled) {
+    throw new PajaSimulationError("Invalid simulation: notifications.enabled must be false when capabilities.domains.notify is false.");
+  }
+  if (!notificationsEnabled) domains.notify = false;
+  const storageMode = raw?.storage?.mode ?? (domains.storage ? "local" : "disabled");
+  if (!domains.storage && storageMode !== "disabled") {
+    throw new PajaSimulationError('Invalid simulation: storage.mode must be "disabled" when capabilities.domains.storage is false.');
+  }
+  if (storageMode === "disabled") domains.storage = false;
+  const identityMode = raw?.identity?.mode ?? "anonymous";
+  const pubkey = raw?.identity?.pubkey?.trim() ?? "";
+  if (identityMode === "fixed" && !isHexPubkey(pubkey)) {
+    throw new PajaSimulationError('Invalid simulation: identity.pubkey must be a 64-character hex string when identity.mode is "fixed".');
+  }
+  const relayUrls = raw?.relay?.urls ?? DEFAULT_RELAY_URLS;
+  if (relayMode === "memory" && relayUrls.length === 0) {
+    throw new PajaSimulationError('Invalid simulation: relay.urls must contain at least one URL when relay.mode is "memory".');
+  }
+  for (const url of relayUrls) {
+    if (typeof url !== "string" || url.trim().length === 0) {
+      throw new PajaSimulationError("Invalid simulation: relay.urls entries must be non-empty strings.");
+    }
+  }
+  const uploadRail = raw?.upload?.rail?.trim() || "dev-memory";
+  if (uploadMode === "memory" && uploadRail.length === 0) {
+    throw new PajaSimulationError('Invalid simulation: upload.rail must be non-empty when upload.mode is "memory".');
+  }
+  return {
+    capabilities: {
+      domains,
+      disabledDomains: PAJA_SIMULATION_DOMAINS.filter((domain) => !domains[domain])
+    },
+    acl: {
+      mode: raw?.acl?.mode ?? "allow"
+    },
+    firewall: {
+      mode: raw?.firewall?.mode ?? "observe"
+    },
+    identity: {
+      mode: identityMode,
+      pubkey: identityMode === "fixed" ? pubkey : ""
+    },
+    relay: {
+      mode: relayMode,
+      urls: relayUrls.map((url) => url.trim()),
+      fixtures: raw?.relay?.fixtures ?? []
+    },
+    storage: {
+      mode: storageMode
+    },
+    cache: {
+      mode: raw?.cache?.mode ?? "memory"
+    },
+    upload: {
+      mode: uploadMode,
+      rail: uploadRail
+    },
+    media: {
+      enabled: mediaEnabled
+    },
+    notifications: {
+      enabled: notificationsEnabled,
+      grant: raw?.notifications?.grant ?? true
+    },
+    config: {
+      values: { ...DEFAULT_CONFIG_VALUES, ...raw?.config?.values }
+    },
+    theme: {
+      mode: raw?.theme?.mode ?? "dark",
+      values: { ...DEFAULT_THEME_VALUES, ...raw?.theme?.values }
+    },
+    intent: {
+      enabled: intentEnabled
+    },
+    cvm: {
+      enabled: cvmEnabled
+    }
+  };
+}
+function summarizePajaSimulation(simulation) {
+  const relay = simulation.relay.mode === "memory" ? `relay:${simulation.relay.urls.length}` : "relay:off";
+  const identity = simulation.identity.mode === "fixed" ? "identity:fixed" : "identity:anon";
+  const storage = `storage:${simulation.storage.mode}`;
+  const theme = `theme:${simulation.theme.mode}`;
+  const disabled = simulation.capabilities.disabledDomains.length > 0 ? `off:${simulation.capabilities.disabledDomains.join(",")}` : "off:none";
+  return `${identity} ${relay} ${storage} ${theme} ${disabled}`;
+}
+function isHexPubkey(value) {
+  return /^[0-9a-fA-F]{64}$/.test(value);
+}
+
+// src/config-file.ts
+function loadPajaConfigFile(configPath) {
+  const resolved = resolve(configPath);
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(resolved, "utf8"));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new PajaSimulationError(`Unable to read --config "${configPath}": ${detail}`);
+  }
+  if (!isRecord(parsed)) {
+    throw new PajaSimulationError(`Invalid --config "${configPath}": expected a JSON object.`);
+  }
+  return parsed;
+}
+function resolvePajaRawOptions(raw) {
+  if (!raw.configPath?.trim()) return raw;
+  return mergePajaRawOptions(loadPajaConfigFile(raw.configPath), raw);
+}
+function mergePajaRawOptions(base, override) {
+  return {
+    targetUrl: override.targetUrl ?? base.targetUrl,
+    command: override.command ?? base.command,
+    host: override.host ?? base.host,
+    port: override.port ?? base.port,
+    readyTimeoutMs: override.readyTimeoutMs ?? base.readyTimeoutMs,
+    configPath: override.configPath ?? base.configPath,
+    simulation: mergeSimulationOptions(base.simulation, override.simulation)
+  };
+}
+function mergeSimulationOptions(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  return {
+    capabilities: {
+      ...base.capabilities,
+      ...override.capabilities,
+      domains: {
+        ...base.capabilities?.domains,
+        ...override.capabilities?.domains
+      }
+    },
+    acl: { ...base.acl, ...override.acl },
+    firewall: { ...base.firewall, ...override.firewall },
+    identity: { ...base.identity, ...override.identity },
+    relay: { ...base.relay, ...override.relay },
+    storage: { ...base.storage, ...override.storage },
+    cache: { ...base.cache, ...override.cache },
+    upload: { ...base.upload, ...override.upload },
+    media: { ...base.media, ...override.media },
+    notifications: { ...base.notifications, ...override.notifications },
+    config: {
+      ...base.config,
+      ...override.config,
+      values: { ...base.config?.values, ...override.config?.values }
+    },
+    theme: {
+      ...base.theme,
+      ...override.theme,
+      values: { ...base.theme?.values, ...override.theme?.values }
+    },
+    intent: { ...base.intent, ...override.intent },
+    cvm: { ...base.cvm, ...override.cvm }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/options.ts
+var PajaOptionsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PajaOptionsError";
+  }
+};
+var DEFAULT_PAJA_HOST = "127.0.0.1";
+var DEFAULT_PAJA_PORT = 5197;
+var DEFAULT_READY_TIMEOUT_MS = 3e4;
+var DEFAULT_PAJA_WINDOW_ID = "kehto-paja-window";
+var DEFAULT_PAJA_DTAG = "dev-target";
+var DEFAULT_PAJA_AGGREGATE_HASH = "paja";
+function normalizePajaOptions(raw) {
+  const targetUrl = normalizeTargetUrl(raw.targetUrl);
+  const host = normalizeHost(raw.host);
+  const port = normalizePort(raw.port, "port");
+  const readyTimeoutMs = normalizePositiveInteger(
+    raw.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS,
+    "ready-timeout"
+  );
+  const command = normalizeCommand(raw.command);
+  const configPath = raw.configPath?.trim();
+  const simulation = normalizePajaSimulation(raw.simulation);
+  return {
+    targetUrl,
+    command,
+    host,
+    port,
+    readyTimeoutMs,
+    configPath: configPath && configPath.length > 0 ? configPath : void 0,
+    simulation,
+    mode: command ? "managed-command" : "external-target"
+  };
+}
+function createPajaHostConfig(options, now = /* @__PURE__ */ new Date()) {
+  return {
+    version: 1,
+    window: {
+      id: DEFAULT_PAJA_WINDOW_ID,
+      dTag: DEFAULT_PAJA_DTAG,
+      aggregateHash: DEFAULT_PAJA_AGGREGATE_HASH
+    },
+    target: {
+      url: options.targetUrl,
+      hmrStrategy: "iframe-target-url",
+      command: options.command
+    },
+    runtime: {
+      host: options.host,
+      port: options.port,
+      readyTimeoutMs: options.readyTimeoutMs,
+      configPath: options.configPath,
+      reloadToken: createReloadToken(now),
+      createdAt: now.toISOString()
+    },
+    chrome: {
+      topBar: true,
+      bottomBar: true,
+      sidePanels: false
+    },
+    simulation: options.simulation
+  };
+}
+function formatPajaUrl(options) {
+  return `http://${options.host}:${options.port}/`;
+}
+function normalizeTargetUrl(value) {
+  const raw = value?.trim();
+  if (!raw) {
+    throw new PajaOptionsError("Missing --target-url. Provide the napplet app URL that the iframe should load.");
+  }
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new PajaOptionsError(`Invalid --target-url "${raw}". Expected an absolute http(s) URL.`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new PajaOptionsError(`Invalid --target-url "${raw}". Only http: and https: URLs are supported.`);
+  }
+  return parsed.href;
+}
+function normalizeHost(value) {
+  const host = value?.trim() || DEFAULT_PAJA_HOST;
+  if (host.length === 0 || host.includes("/")) {
+    throw new PajaOptionsError(`Invalid --host "${value ?? ""}". Provide a hostname or IP address.`);
+  }
+  return host;
+}
+function normalizePort(value, label) {
+  return normalizeIntegerInRange(value ?? DEFAULT_PAJA_PORT, label, 0, 65535);
+}
+function normalizePositiveInteger(value, label, max = Number.MAX_SAFE_INTEGER) {
+  return normalizeIntegerInRange(value, label, 1, max);
+}
+function normalizeIntegerInRange(value, label, min, max) {
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+    throw new PajaOptionsError(`Invalid --${label} "${String(value)}". Expected an integer from ${min} to ${max}.`);
+  }
+  return parsed;
+}
+function normalizeCommand(command) {
+  if (!command) return void 0;
+  if (command.mode === "argv") {
+    const argv = command.argv.map((part) => part.trim()).filter((part) => part.length > 0);
+    if (argv.length === 0) {
+      throw new PajaOptionsError("Command mode requires at least one command argument after --.");
+    }
+    return { mode: "argv", argv };
+  }
+  const shellCommand = command.command.trim();
+  if (shellCommand.length === 0) {
+    throw new PajaOptionsError("--command requires a non-empty command string.");
+  }
+  return { mode: "shell", command: shellCommand };
+}
+function createReloadToken(now) {
+  const iso = now.toISOString();
+  return `reload-${iso.replaceAll(/[^0-9A-Za-z]/g, "")}`;
+}
+
+// src/host-page.ts
+function renderPajaHtml(config) {
+  const configJson = escapeJsonForHtml(JSON.stringify(config));
+  const targetUrl = escapeAttribute(config.target.url);
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Kehto Paja</title>
+    <style>
+      :root {
+        color-scheme: dark;
+        --bg: #101211;
+        --bar: #181b19;
+        --line: #30352f;
+        --text: #f4f0df;
+        --muted: #a9ad9f;
+        --accent: #d8c36a;
+      }
+      * { box-sizing: border-box; }
+      html, body { margin: 0; min-height: 100%; background: var(--bg); color: var(--text); font: 13px/1.4 ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+      body { height: 100vh; display: grid; grid-template-rows: 38px minmax(0, 1fr) 30px; overflow: hidden; }
+      .bar { display: flex; align-items: center; gap: 14px; min-width: 0; padding: 0 12px; background: var(--bar); border-color: var(--line); }
+      .top { border-bottom: 1px solid var(--line); }
+      .bottom { border-top: 1px solid var(--line); color: var(--muted); font-size: 12px; }
+      .brand { font-weight: 700; letter-spacing: 0; color: var(--accent); white-space: nowrap; }
+      .target { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--muted); }
+      .spacer { flex: 1; min-width: 0; }
+      button { border: 1px solid var(--line); color: var(--text); background: #20241f; height: 26px; padding: 0 10px; border-radius: 4px; font: inherit; cursor: pointer; }
+      button:hover { border-color: var(--accent); }
+      label { display: inline-flex; align-items: center; gap: 6px; color: var(--muted); white-space: nowrap; }
+      select { border: 1px solid var(--line); color: var(--text); background: #20241f; height: 26px; border-radius: 4px; font: inherit; }
+      iframe { width: 100%; height: 100%; border: 0; background: white; display: block; }
+      code { color: var(--text); }
+    </style>
+  </head>
+  <body>
+    <header class="bar top">
+      <div class="brand">Kehto</div>
+      <div class="target" title="${targetUrl}">${targetUrl}</div>
+      <div class="spacer"></div>
+      <label>theme
+        <select id="simulation-theme" aria-label="Simulation theme">
+          <option value="dark"${config.simulation.theme.mode === "dark" ? " selected" : ""}>dark</option>
+          <option value="light"${config.simulation.theme.mode === "light" ? " selected" : ""}>light</option>
+        </select>
+      </label>
+      <button type="button" id="reload-target">Reload</button>
+    </header>
+    <main>
+      <iframe id="napplet-frame" title="Napplet development target" sandbox="allow-scripts" data-target-url="${targetUrl}"></iframe>
+    </main>
+    <footer class="bar bottom">
+      <span>mode: <code>${config.target.command ? "managed-command" : "external-target"}</code></span>
+      <span>hmr: <code>${config.target.hmrStrategy}</code></span>
+      <span>runtime: <code>${escapeHtml(config.runtime.host)}:${config.runtime.port}</code></span>
+      <span>sim: <code id="simulation-status">${escapeHtml(summarizePajaSimulation(config.simulation))}</code></span>
+      <span>state: <code id="lifecycle-status">booting</code></span>
+    </footer>
+    <script type="application/json" id="kehto-paja-config">${configJson}</script>
+    <script type="module" src="/__kehto/browser-host.js"></script>
+  </body>
+</html>`;
+}
+function escapeAttribute(value) {
+  return escapeHtml(value).replaceAll('"', "&quot;");
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeJsonForHtml(value) {
+  return value.replaceAll("<", "\\u003c");
+}
+
+// src/parity.ts
+var PAJA_LEGACY_COMPATIBILITY_DOMAIN = `i${"fc"}`;
+var PAJA_UPSTREAM_WEB_DOMAINS = [
+  "config",
+  "cvm",
+  "identity",
+  PAJA_LEGACY_COMPATIBILITY_DOMAIN,
+  "inc",
+  "intent",
+  "keys",
+  "media",
+  "notify",
+  "outbox",
+  "relay",
+  "resource",
+  "shell",
+  "storage",
+  "theme",
+  "upload"
+];
+var PAJA_HANDSHAKE_DOMAINS = ["shell"];
+var PAJA_COMPATIBILITY_ALIASES = {
+  [PAJA_LEGACY_COMPATIBILITY_DOMAIN]: "inc"
+};
+var PAJA_ADVERTISED_DOMAINS = [
+  "relay",
+  "outbox",
+  "identity",
+  "storage",
+  "inc",
+  "theme",
+  "keys",
+  "media",
+  "notify",
+  "config",
+  "resource",
+  "cvm",
+  "upload",
+  "intent"
+];
+var PAJA_REQUIRED_SERVICES = [
+  "config",
+  "cvm",
+  "identity",
+  "intent",
+  "keys",
+  "media",
+  "notifications",
+  "notify",
+  "outbox",
+  "relay",
+  "resource",
+  "theme",
+  "upload"
+];
+function getMissingAdvertisedDomains(capabilities) {
+  const advertised = new Set(capabilities.domains);
+  return PAJA_ADVERTISED_DOMAINS.filter((domain) => !advertised.has(domain));
+}
+function getMissingServices(services) {
+  const wired = new Set(services);
+  return PAJA_REQUIRED_SERVICES.filter((service) => !wired.has(service));
+}
+
+// src/readiness.ts
+var ReadinessError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ReadinessError";
+  }
+};
+async function waitForTargetUrl(url, options) {
+  const intervalMs = options.intervalMs ?? 250;
+  const fetcher = options.fetch ?? defaultFetch;
+  const sleep = options.sleep ?? defaultSleep;
+  const now = options.now ?? Date.now;
+  const deadline = now() + options.timeoutMs;
+  let lastError = "no response";
+  while (now() <= deadline) {
+    try {
+      const response = await fetcher(url);
+      if (response.status < 500) {
+        return;
+      }
+      lastError = `status ${response.status}`;
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+    }
+    await sleep(intervalMs);
+  }
+  throw new ReadinessError(`Timed out waiting ${options.timeoutMs}ms for target URL ${url}: ${lastError}`);
+}
+async function defaultFetch(url) {
+  return fetch(url, { method: "GET", redirect: "follow" });
+}
+function defaultSleep(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
+  });
+}
+
+// src/server.ts
+import { createServer } from "http";
+import { readFileSync as readFileSync2 } from "fs";
+async function startPajaServer(input) {
+  const rawOptions = resolvePajaRawOptions(input.options);
+  const options = normalizePajaOptions(rawOptions);
+  let hostConfig = createPajaHostConfig(options, input.now);
+  let html = renderPajaHtml(hostConfig);
+  let configJson = JSON.stringify(hostConfig, null, 2);
+  const server = createServer((request, response) => {
+    const requestUrl = request.url ?? "/";
+    if (requestUrl === "/" || requestUrl.startsWith("/?")) {
+      response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      response.end(html);
+      return;
+    }
+    if (requestUrl === "/__kehto/config.json") {
+      response.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+      response.end(configJson);
+      return;
+    }
+    if (requestUrl === "/__kehto/browser-host.js") {
+      const browserScript = readBrowserHostScript();
+      response.writeHead(200, { "content-type": "text/javascript; charset=utf-8" });
+      response.end(browserScript);
+      return;
+    }
+    response.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+    response.end("Not found");
+  });
+  await listen(server, options.host, options.port);
+  const servedOptions = withBoundPort(options, getBoundPort(server, options.port));
+  hostConfig = createPajaHostConfig(servedOptions, input.now);
+  html = renderPajaHtml(hostConfig);
+  configJson = JSON.stringify(hostConfig, null, 2);
+  return {
+    url: formatPajaUrl(servedOptions),
+    hostConfig,
+    close: () => close(server)
+  };
+}
+function readBrowserHostScript() {
+  return readFileSync2(new URL("./browser-host.js", import.meta.url), "utf8");
+}
+function listen(server, host, port) {
+  return new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      server.off("error", reject);
+      resolve2();
+    });
+  });
+}
+function close(server) {
+  return new Promise((resolve2, reject) => {
+    server.close((error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve2();
+    });
+  });
+}
+function getBoundPort(server, fallback) {
+  const address = server.address();
+  return typeof address === "object" && address !== null ? address.port : fallback;
+}
+function withBoundPort(options, port) {
+  return port === options.port ? options : { ...options, port };
+}
+
+export {
+  PajaSimulationError,
+  PAJA_SIMULATION_DOMAINS,
+  normalizePajaSimulation,
+  summarizePajaSimulation,
+  loadPajaConfigFile,
+  resolvePajaRawOptions,
+  mergePajaRawOptions,
+  PajaOptionsError,
+  DEFAULT_PAJA_HOST,
+  DEFAULT_PAJA_PORT,
+  DEFAULT_READY_TIMEOUT_MS,
+  DEFAULT_PAJA_WINDOW_ID,
+  DEFAULT_PAJA_DTAG,
+  DEFAULT_PAJA_AGGREGATE_HASH,
+  normalizePajaOptions,
+  createPajaHostConfig,
+  formatPajaUrl,
+  renderPajaHtml,
+  PAJA_UPSTREAM_WEB_DOMAINS,
+  PAJA_HANDSHAKE_DOMAINS,
+  PAJA_COMPATIBILITY_ALIASES,
+  PAJA_ADVERTISED_DOMAINS,
+  PAJA_REQUIRED_SERVICES,
+  getMissingAdvertisedDomains,
+  getMissingServices,
+  ReadinessError,
+  waitForTargetUrl,
+  startPajaServer
+};
+//# sourceMappingURL=chunk-BM6ROSMJ.js.map