@mrcharles/sdk 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,114 @@
-# Temporary Holding Version
+# @mrcharles/sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Put Mr Charles booking on any website: studio rooms (guests, no account) and
+teacher lessons (hand-off to the app). Zero dependencies, ~6 kB min+gz, works
+in the browser, in Astro/Next/SvelteKit server code, and as a plain `<script>`.
+
+Docs: https://developers.mrcharles.app/integrate/sdk/
+
+## Install
+
+```bash
+npm i @mrcharles/sdk
+```
+
+or without a bundler:
+
+```html
+<script src="https://developers.mrcharles.app/sdk/v0/mrcharles.min.js"></script>
+<!-- exposes window.MrCharles -->
+```
+
+## 30-second version: embed our booking screen
+
+```js
+import { createClient } from '@mrcharles/sdk';
+
+const mc = createClient();
+mc.mountRoomBooking('#book', {
+  slug: 'studio-uno-madrid',
+  roomId: 'd9a36c09-d151-5d4a-a077-296293b07be4',
+  lang: 'es',
+  onBooked: ({ reference, manageUrl }) => console.log('booked', reference, manageUrl),
+});
+```
+
+The iframe resizes to its content, takes card deposits, sends the SMS code,
+and shows the manage link. You write nothing else.
+
+## Your own UI: the headless flow
+
+```js
+const flow = mc.roomBooking({ slug, roomId, onChange: render });
+
+await flow.loadSite();                                  // rooms, prices, timezone, captcha/stripe keys
+await flow.loadAvailability({ days: 14 });              // free spans, studio's zone
+flow.startTimesFor('2026-10-20', 120);                  // → ['09:00', '10:00', …]
+flow.durationsFor('2026-10-20', '10:00');               // → [60, 120, 180]
+
+await flow.hold({ date, startTime, durationMinutes, guestName, channel: 'phone', contact: '+34600111222' });
+// state.step === 'verify' · flow.remainingMs() counts down from 12 min
+await flow.verify(code);                                // 6 digits; flow.resend() after 60 s
+await flow.confirm({ paymentMode: 'on_site', notes }); // state.step === 'done'
+flow.state.confirmation.manageUrl;                      // hand this to the guest
+```
+
+Every error is a `MrCharlesError` with a stable `code` (`SLOT_TAKEN`,
+`HOLD_EXPIRED`, `CODE_INVALID`, …) and three helpers: `slotIsGone`,
+`holdIsDead`, `isTransient`. The flow rotates the idempotency key when a hold
+dies and keeps it across network retries, so you can simply call `hold()` again.
+
+## Lessons with a teacher
+
+```js
+const t = await mc.teachers.profile(teacherUserId);
+const offers = await mc.teachers.offers(teacherUserId);
+const slots = await mc.teachers.slots({ instructorUserId: t.user.id, offerId: offers[0].id, date: '2026-10-13', days: 7 });
+// <a href={mc.links.bookLesson({ offerId: offers[0].id, instructorId: t.user.id })}>Book</a>
+```
+
+Students book inside the Mr Charles app (payment, reminders, cancellations),
+so the SDK gives you the reads and the link, not a guest checkout.
+
+## Astro
+
+```astro
+---
+import { createClient } from '@mrcharles/sdk';
+const mc = createClient();
+const site = await mc.sites.get('studio-uno-madrid');   // at build / on request
+---
+<h1>{site.studio.name}</h1>
+{site.rooms.filter((r) => r.bookable).map((r) => <a href={mc.links.bookRoom({ slug: site.studio.slug, roomId: r.id })}>{r.name}</a>)}
+<div id="book"></div>
+<script>
+  import { createClient } from '@mrcharles/sdk';
+  createClient().mountRoomBooking('#book', { slug: 'studio-uno-madrid', roomId: '…' });
+</script>
+```
+
+Availability and holds must run in the browser (or forward the guest's IP in
+`headers: { 'X-Forwarded-For': ip }` when you proxy them).
+
+## API surface
+
+| | |
+|---|---|
+| `createClient({ fetch, locale, headers })` | one client |
+| `sites.get / resolve / availability` | studio payload, custom-domain lookup, free spans |
+| `holds.create / verify / resend / confirm` | the raw calls, if you manage state yourself |
+| `bookings.get / cancel` | a guest's booking by manage token |
+| `teachers.profile / offers / offer / windows / policy / slots` | lesson reads |
+| `links.site / bookRoom / manage / bookLesson / teacherProfile` | URLs for every hand-off |
+| `mountRoomBooking(target, opts)` | iframe embed with resize + booked events |
+| `roomBooking(opts)` | the stateful flow above |
+| `startTimes / durationOptions / formatPrice / dateKey / addDays` | helpers |
+
+## Testing without bothering anyone
+
+There is one API. To develop, point the SDK at a studio site in **sandbox
+mode** — the platform's `demo-studio`, or your own site with *Modo pruebas*
+switched on in the dashboard. A sandbox site returns the verification code
+as `hold.devCode`, sends no SMS or email, offers `on_site` only, and purges
+its bookings after seven days. `site.site.sandbox` tells you which mode you
+are in; switch the slug to the real one at launch and nothing else changes.

package/dist/mrcharles.esm.js

@@ -0,0 +1,509 @@
+// src/env.ts
+var ENVIRONMENTS = {
+  production: {
+    apiBase: "https://api.mrcharles.app/api/v1",
+    appBase: "https://app.mrcharles.app",
+    sitesBase: "sites.mrcharles.app"
+  }
+};
+function resolveEndpoints(config = {}) {
+  const base = ENVIRONMENTS[config.env ?? "production"];
+  return {
+    apiBase: trimSlash(config.apiBase ?? base.apiBase),
+    appBase: trimSlash(config.appBase ?? base.appBase),
+    sitesBase: (config.sitesBase ?? base.sitesBase).replace(/^https?:\/\//, "").replace(/\/+$/, "")
+  };
+}
+function trimSlash(s) {
+  return s.replace(/\/+$/, "");
+}
+
+// src/errors.ts
+class MrCharlesError extends Error {
+  code;
+  status;
+  requestId;
+  constructor(code, message, status = 0, requestId) {
+    super(message);
+    this.name = "MrCharlesError";
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+  }
+  get holdIsDead() {
+    return this.code === "HOLD_EXPIRED" || this.code === "TOO_MANY_ATTEMPTS";
+  }
+  get slotIsGone() {
+    return this.code === "SLOT_TAKEN" || this.code === "OUTSIDE_HOURS" || this.code === "OUTSIDE_BOOKING_WINDOW";
+  }
+  get isTransient() {
+    return this.code === "NETWORK_ERROR" || this.status >= 500;
+  }
+}
+function isMrCharlesError(e) {
+  return e instanceof MrCharlesError || typeof e === "object" && e !== null && e.name === "MrCharlesError";
+}
+
+// src/http.ts
+function createHttp(apiBase, config) {
+  const resolved = config.fetch ?? (typeof fetch === "function" ? fetch.bind(globalThis) : undefined);
+  if (!resolved)
+    throw new Error("@mrcharles/sdk: no fetch available — pass { fetch } in the client config");
+  const doFetch = resolved;
+  async function request(method, path, body, params) {
+    let url = apiBase + path;
+    if (params) {
+      const q = new URLSearchParams;
+      for (const [k, v] of Object.entries(params))
+        if (v !== undefined && v !== "")
+          q.set(k, String(v));
+      const s = q.toString();
+      if (s)
+        url += (url.includes("?") ? "&" : "?") + s;
+    }
+    const headers = { Accept: "application/json", ...config.headers ?? {} };
+    if (config.locale)
+      headers["Accept-Language"] = config.locale;
+    if (body !== undefined)
+      headers["Content-Type"] = "application/json";
+    let res;
+    try {
+      res = await doFetch(url, { method, headers, body: body !== undefined ? JSON.stringify(body) : undefined, cache: "no-store" });
+    } catch (e) {
+      throw new MrCharlesError("NETWORK_ERROR", e?.message || "Network error", 0);
+    }
+    const requestId = res.headers?.get?.("x-request-id") ?? undefined;
+    const text = await res.text();
+    let json = null;
+    try {
+      json = text ? JSON.parse(text) : null;
+    } catch {
+      json = null;
+    }
+    const envelope = json && typeof json === "object" ? json : {};
+    if (!res.ok || envelope.success === false) {
+      const code = envelope.error?.code ?? (res.status === 429 ? "RATE_LIMIT_EXCEEDED" : res.status === 404 ? "RESOURCE_NOT_FOUND" : "INTERNAL_ERROR");
+      const message = envelope.error?.message ?? res.statusText ?? "Request failed";
+      throw new MrCharlesError(code, message, res.status, requestId);
+    }
+    return "data" in envelope ? envelope.data : json;
+  }
+  return {
+    get: (path, params) => request("GET", path, undefined, params),
+    post: (path, body) => request("POST", path, body ?? {})
+  };
+}
+
+// src/links.ts
+function createLinks(endpoints) {
+  const siteOrigin = (slug) => `https://${slug}.${endpoints.sitesBase}`;
+  return {
+    site(slug) {
+      return `${siteOrigin(slug)}/`;
+    },
+    bookRoom(o) {
+      const q = new URLSearchParams;
+      if (o.date)
+        q.set("date", o.date);
+      if (o.start)
+        q.set("start", o.start);
+      if (o.durationMinutes)
+        q.set("duration", String(o.durationMinutes));
+      if (o.lang)
+        q.set("lang", o.lang);
+      if (o.embed)
+        q.set("embed", "1");
+      const s = q.toString();
+      return `${siteOrigin(o.slug)}/reservar/${o.roomId}${s ? `?${s}` : ""}`;
+    },
+    manage(slug, manageToken) {
+      return `${siteOrigin(slug)}/r/${manageToken}`;
+    },
+    bookLesson(o) {
+      const q = new URLSearchParams({ instructorId: o.instructorId });
+      if (o.offerId)
+        q.set("offerId", o.offerId);
+      return `${endpoints.appBase}/bookings/book?${q.toString()}`;
+    },
+    teacherProfile(instructorUserId) {
+      return `${endpoints.appBase}/instructors/${instructorUserId}`;
+    }
+  };
+}
+
+// src/embed.ts
+function isTrustedOrigin(origin, sitesBase) {
+  try {
+    const host = new URL(origin).host;
+    return host === sitesBase || host.endsWith(`.${sitesBase}`);
+  } catch {
+    return false;
+  }
+}
+function parseEmbedEvent(data) {
+  if (!data || typeof data !== "object")
+    return null;
+  const d = data;
+  if (d.type === "mrcharles:resize" && typeof d.height === "number")
+    return { type: "mrcharles:resize", height: d.height };
+  if (d.type === "mrcharles:booked" && typeof d.reference === "string") {
+    return {
+      type: "mrcharles:booked",
+      reference: d.reference,
+      bookingId: String(d.bookingId ?? ""),
+      manageUrl: String(d.manageUrl ?? ""),
+      status: String(d.status ?? "")
+    };
+  }
+  return null;
+}
+function createEmbed(endpoints) {
+  const links = createLinks(endpoints);
+  function mountRoomBooking(target, opts) {
+    const el = typeof target === "string" ? document.querySelector(target) : target;
+    if (!el)
+      throw new Error(`@mrcharles/sdk: embed target not found: ${String(target)}`);
+    const iframe = document.createElement("iframe");
+    iframe.src = links.bookRoom({ ...opts, embed: true });
+    iframe.title = opts.title ?? "Mr Charles booking";
+    iframe.loading = "lazy";
+    iframe.referrerPolicy = "strict-origin-when-cross-origin";
+    iframe.setAttribute("allow", "payment");
+    iframe.style.width = "100%";
+    iframe.style.border = "0";
+    iframe.style.display = "block";
+    iframe.style.height = `${opts.height ?? 760}px`;
+    if (opts.className)
+      iframe.className = opts.className;
+    const expectedOrigin = new URL(iframe.src).origin;
+    const onMessage = (e) => {
+      if (e.source !== iframe.contentWindow)
+        return;
+      if (e.origin !== expectedOrigin && !isTrustedOrigin(e.origin, endpoints.sitesBase))
+        return;
+      const ev = parseEmbedEvent(e.data);
+      if (!ev)
+        return;
+      if (ev.type === "mrcharles:resize") {
+        if (opts.autoResize !== false)
+          iframe.style.height = `${ev.height}px`;
+        opts.onResize?.(ev.height);
+      } else {
+        opts.onBooked?.(ev);
+      }
+    };
+    window.addEventListener("message", onMessage);
+    el.appendChild(iframe);
+    return {
+      iframe,
+      destroy() {
+        window.removeEventListener("message", onMessage);
+        iframe.remove();
+      }
+    };
+  }
+  return { mountRoomBooking };
+}
+
+// src/uuid.ts
+function uuid() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID)
+    return c.randomUUID();
+  const b = new Uint8Array(16);
+  if (c?.getRandomValues)
+    c.getRandomValues(b);
+  else
+    for (let i = 0;i < 16; i++)
+      b[i] = Math.floor(Math.random() * 256);
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const h = [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+
+// src/slots.ts
+function toMinutes(hhmm) {
+  const [h, m] = hhmm.split(":").map(Number);
+  return (h || 0) * 60 + (m || 0);
+}
+function toHHMM(minutes) {
+  const h = Math.floor(minutes / 60);
+  const m = minutes % 60;
+  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+}
+function addMinutes(hhmm, minutes) {
+  return toHHMM(toMinutes(hhmm) + minutes);
+}
+function startTimes(free, durationMinutes, stepMinutes) {
+  const step = Math.max(1, stepMinutes);
+  const out = new Set;
+  for (const span of free) {
+    const s = toMinutes(span.start);
+    const e = toMinutes(span.end);
+    for (let t = Math.ceil(s / step) * step;t + durationMinutes <= e; t += step)
+      out.add(toHHMM(t));
+  }
+  return [...out].sort((a, b) => toMinutes(a) - toMinutes(b));
+}
+function durationOptions(free, start, minMinutes, maxMinutes, stepMinutes) {
+  const s = toMinutes(start);
+  const span = free.find((f) => toMinutes(f.start) <= s && s < toMinutes(f.end));
+  if (!span)
+    return [];
+  const room = toMinutes(span.end) - s;
+  const out = [];
+  for (let d = minMinutes;d <= maxMinutes && d <= room; d += Math.max(1, stepMinutes))
+    out.push(d);
+  return out;
+}
+function formatPrice(cents, currency, locale = "es-ES") {
+  try {
+    return new Intl.NumberFormat(locale, { style: "currency", currency }).format(cents / 100);
+  } catch {
+    return `${(cents / 100).toFixed(2)} ${currency}`;
+  }
+}
+function dateKey(date, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(date);
+  const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
+  return `${get("year")}-${get("month")}-${get("day")}`;
+}
+function addDays(key, days) {
+  const [y, m, d] = key.split("-").map(Number);
+  const t = Date.UTC(y, m - 1, d + days);
+  return new Date(t).toISOString().slice(0, 10);
+}
+
+// src/rooms.ts
+function createRoomBooking(http, links, opts) {
+  let state = { step: "slot", site: null, room: null, availability: null, hold: null, confirmation: null, error: null, busy: false };
+  const listeners = new Set;
+  if (opts.onChange)
+    listeners.add(opts.onChange);
+  let idempotencyKey = uuid();
+  let expiryTimer;
+  const set = (patch) => {
+    state = { ...state, ...patch };
+    for (const l of listeners)
+      l(state);
+  };
+  const clearTimer = () => {
+    if (expiryTimer)
+      clearTimeout(expiryTimer);
+    expiryTimer = undefined;
+  };
+  const armTimer = (hold) => {
+    clearTimer();
+    const ms = new Date(hold.expiresAt).getTime() - Date.now();
+    if (ms <= 0)
+      return;
+    expiryTimer = setTimeout(() => {
+      if (state.step === "verify" || state.step === "pay") {
+        idempotencyKey = uuid();
+        set({ step: "expired", error: new MrCharlesError("HOLD_EXPIRED", "The hold expired. Pick a time again.", 410) });
+      }
+    }, ms);
+  };
+  async function run(fn) {
+    set({ busy: true });
+    try {
+      const out = await fn();
+      set({ busy: false, error: null });
+      return out;
+    } catch (e) {
+      const err = isMrCharlesError(e) ? e : new MrCharlesError("INTERNAL_ERROR", e?.message ?? "Unexpected error");
+      if (err.holdIsDead) {
+        clearTimer();
+        idempotencyKey = uuid();
+        set({ busy: false, error: err, step: "expired", hold: null });
+      } else {
+        set({ busy: false, error: err });
+      }
+      throw err;
+    }
+  }
+  const api = {
+    get state() {
+      return state;
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      fn(state);
+      return () => {
+        listeners.delete(fn);
+      };
+    },
+    loadSite: () => run(async () => {
+      const site = await http.get(`/public/sites/${encodeURIComponent(opts.slug)}`);
+      const room = site.rooms.find((r) => r.id === opts.roomId) ?? null;
+      if (!room)
+        throw new MrCharlesError("RESOURCE_NOT_FOUND", `Room ${opts.roomId} is not on site ${opts.slug}`, 404);
+      if (!room.bookable)
+        throw new MrCharlesError("ROOM_NOT_BOOKABLE", `${room.name} does not take online bookings right now`, 409);
+      set({ site, room });
+      return site;
+    }),
+    loadAvailability: (window2 = {}) => run(async () => {
+      const tz = state.site?.studio.timezone ?? "UTC";
+      const from = window2.from ?? dateKey(new Date, tz);
+      const to = window2.to ?? addDays(from, Math.min(31, Math.max(1, window2.days ?? 14)) - 1);
+      const availability = await http.get(`/public/sites/${encodeURIComponent(opts.slug)}/rooms/${encodeURIComponent(opts.roomId)}/availability`, { from, to });
+      set({ availability });
+      return availability;
+    }),
+    startTimesFor(date, durationMinutes) {
+      const a = state.availability;
+      if (!a)
+        return [];
+      const day = a.days.find((d) => d.date === date);
+      return day ? startTimes(day.free, durationMinutes, a.stepMinutes) : [];
+    },
+    durationsFor(date, startTime) {
+      const a = state.availability;
+      if (!a)
+        return [];
+      const day = a.days.find((d) => d.date === date);
+      return day ? durationOptions(day.free, startTime, a.minMinutes, a.maxMinutes, a.stepMinutes) : [];
+    },
+    hold: (details) => run(async () => {
+      if (state.step === "expired")
+        set({ step: "slot", error: null });
+      const body = {
+        roomId: opts.roomId,
+        date: details.date,
+        startTime: details.startTime,
+        durationMinutes: details.durationMinutes,
+        guestName: details.guestName,
+        channel: details.channel,
+        contact: details.contact,
+        locale: details.locale ?? state.site?.site.defaultLocale ?? "es",
+        idempotencyKey,
+        ...details.captchaToken ? { captchaToken: details.captchaToken } : {}
+      };
+      const hold = await http.post(`/public/sites/${encodeURIComponent(opts.slug)}/holds`, body);
+      armTimer(hold);
+      set({ hold, step: "verify", confirmation: null });
+      return hold;
+    }),
+    verify: (code) => run(async () => {
+      const id = requireHold(state).holdId;
+      const hold = await http.post(`/public/holds/${id}/verify`, { code: code.replace(/\D/g, "") });
+      set({ hold, step: "pay" });
+      return hold;
+    }),
+    resend: () => run(async () => {
+      const id = requireHold(state).holdId;
+      const hold = await http.post(`/public/holds/${id}/resend`);
+      set({ hold });
+      return hold;
+    }),
+    confirm: (req) => run(async () => {
+      const h = requireHold(state);
+      if (!h.paymentModes.includes(req.paymentMode)) {
+        throw new MrCharlesError("PAYMENT_MODE_DENIED", `This room does not accept ${req.paymentMode}`, 409);
+      }
+      const confirmation = await http.post(`/public/holds/${h.holdId}/confirm`, {
+        paymentMode: req.paymentMode,
+        notes: req.notes ?? "",
+        email: req.email ?? ""
+      });
+      clearTimer();
+      if (!confirmation.manageUrl && confirmation.manageToken)
+        confirmation.manageUrl = links.manage(opts.slug, confirmation.manageToken);
+      set({ confirmation, step: "done" });
+      return confirmation;
+    }),
+    remainingMs() {
+      const h = state.hold;
+      if (!h || state.step === "done" || state.step === "expired")
+        return 0;
+      return Math.max(0, new Date(h.expiresAt).getTime() - Date.now());
+    },
+    reset() {
+      clearTimer();
+      idempotencyKey = uuid();
+      set({ step: "slot", hold: null, confirmation: null, error: null, busy: false });
+    },
+    destroy() {
+      clearTimer();
+      listeners.clear();
+    }
+  };
+  return api;
+}
+function requireHold(s) {
+  if (!s.hold)
+    throw new MrCharlesError("INVALID_STATE", "No hold yet — call hold() first", 409);
+  return s.hold;
+}
+
+// src/client.ts
+function createClient(config = {}) {
+  const endpoints = resolveEndpoints(config);
+  const http = createHttp(endpoints.apiBase, config);
+  const links = createLinks(endpoints);
+  const embed = createEmbed(endpoints);
+  const enc = encodeURIComponent;
+  const sites = {
+    get: (slug) => http.get(`/public/sites/${enc(slug)}`),
+    resolve: (host) => http.get("/public/sites/resolve", { host }),
+    availability: (slug, roomId, range) => http.get(`/public/sites/${enc(slug)}/rooms/${enc(roomId)}/availability`, range)
+  };
+  const holds = {
+    create: (slug, req) => http.post(`/public/sites/${enc(slug)}/holds`, req),
+    verify: (holdId, code) => http.post(`/public/holds/${enc(holdId)}/verify`, { code }),
+    resend: (holdId) => http.post(`/public/holds/${enc(holdId)}/resend`),
+    confirm: (holdId, req) => http.post(`/public/holds/${enc(holdId)}/confirm`, { paymentMode: req.paymentMode, notes: req.notes ?? "", email: req.email ?? "" })
+  };
+  const bookings = {
+    get: (manageToken) => http.get(`/public/bookings/manage/${enc(manageToken)}`),
+    cancel: (manageToken, reason = "") => http.post(`/public/bookings/manage/${enc(manageToken)}/cancel`, { reason })
+  };
+  const teachers = {
+    profile: (instructorUserId) => http.get(`/instructors/${enc(instructorUserId)}/teacher-profile`),
+    offers: (instructorUserId) => http.get(`/instructors/${enc(instructorUserId)}/offers`),
+    offer: (offerId) => http.get(`/offers/${enc(offerId)}`),
+    windows: (instructorUserId, range) => http.get(`/availability/${enc(instructorUserId)}/windows`, range),
+    policy: (instructorUserId) => http.get(`/availability/${enc(instructorUserId)}/policy`),
+    slots: (q) => http.get("/bookings/slots", { instructorId: q.instructorUserId, offerId: q.offerId, date: q.date, days: q.days ?? 7 })
+  };
+  return {
+    endpoints,
+    sites,
+    holds,
+    bookings,
+    teachers,
+    links,
+    mountRoomBooking: embed.mountRoomBooking,
+    roomBooking: (opts) => createRoomBooking(http, links, opts)
+  };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  ENVIRONMENTS,
+  MrCharlesError,
+  VERSION,
+  addDays,
+  addMinutes,
+  createClient,
+  createEmbed,
+  createLinks,
+  createRoomBooking,
+  dateKey,
+  durationOptions,
+  formatPrice,
+  isMrCharlesError,
+  isTrustedOrigin,
+  parseEmbedEvent,
+  resolveEndpoints,
+  startTimes,
+  toHHMM,
+  toMinutes,
+  uuid
+};
+
+//# debugId=147361D96F83431064756E2164756E21
+//# sourceMappingURL=mrcharles.esm.js.map