api_binding_ui 3.1.0 → 3.2.0

package/dist/app/index.html

@@ -2,6 +2,6 @@
 <html lang="en">
 <head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>Bind API</title>
 <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=JetBrains+Mono:wght@500;600&display=swap" />
-<style>html, body, #root { height: 100%; margin: 0; overflow: hidden; background: #f8fafc; }</style><link rel="stylesheet" crossorigin href="./index-aaxy714b.css"><script type="module" crossorigin src="./index-4mgcb4wd.js"></script></head>
+<style>html, body, #root { height: 100%; margin: 0; overflow: hidden; background: #f8fafc; }</style><link rel="stylesheet" crossorigin href="./index-aaxy714b.css"><script type="module" crossorigin src="./index-xww2x0kd.js"></script></head>
 <body><div id="root"></div></body>
 </html>

package/dist/cli/scan.d.ts

@@ -0,0 +1,2 @@
+import type { BindingsFile, ValidationIssue } from "../framework/contract";
+export declare function scanIds(dir: string, file: BindingsFile): Promise<ValidationIssue[]>;

package/dist/cli.js

@@ -2,98 +2,12 @@
 
 // src/cli/cli.ts
 import { createServer } from "node:http";
+import path4 from "node:path";
+
+// src/codegen/write.ts
 import { promises as fs3 } from "node:fs";
 import path3 from "node:path";
 
-// src/framework/names.ts
-function humanize(id) {
-  const s = id.replace(/^\$\.?/, "").replace(/\[\*\]/g, "").split(/[./]/).filter(Boolean).pop() ?? id;
-  const w = s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase().trim();
-  return w ? w[0].toUpperCase() + w.slice(1) : id;
-}
-
-// src/framework/file.ts
-var ID = /^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/;
-var BINDING_TYPES = new Set(["operation", "expression", "steps", "none"]);
-function parseBindingsFile(text) {
-  let data;
-  try {
-    data = JSON.parse(text);
-  } catch {
-    throw new Error("The bindings file is not valid JSON.");
-  }
-  const f = data;
-  if (!f || typeof f !== "object")
-    throw new Error("The bindings file must be a JSON object.");
-  if (f.version !== 3)
-    throw new Error(`The bindings file must have "version": 3.`);
-  if (typeof f.openapi !== "string" || !f.openapi)
-    throw new Error(`The bindings file needs "openapi": the docs URL or a path.`);
-  for (const k of ["kinds", "screens", "components", "bindings"])
-    if (!Array.isArray(f[k]))
-      throw new Error(`"${k}" must be a list.`);
-  f.bindings.forEach((b, i) => {
-    const x = b;
-    if (!x || typeof x.component !== "string" || typeof x.slot !== "string" || !BINDING_TYPES.has(x.type))
-      throw new Error(`Binding ${i + 1} needs "component", "slot" and a known "type".`);
-  });
-  if (f.output && (typeof f.output.dir !== "string" || typeof f.output.client !== "string"))
-    throw new Error(`"output" needs "dir" and "client".`);
-  return f;
-}
-function screenOf(id, screens) {
-  let best;
-  for (const s of screens)
-    if (id.startsWith(s + ".") && (!best || s.length > best.length))
-      best = s;
-  return best;
-}
-function productLabel(seg, catalog) {
-  const names = new Set(catalog.operations.map((o) => o.product).filter((p) => !!p));
-  return [...names].find((n) => n.toLowerCase().replace(/[^a-z0-9]+/g, "-") === seg) ?? humanize(seg);
-}
-function fromFile(file, catalog) {
-  const issues = [];
-  const ids = file.screens.map((s) => s.id);
-  const screens = file.screens.map((s) => ({
-    id: s.id,
-    label: s.label,
-    description: s.description,
-    context: s.context ?? [],
-    components: [],
-    path: [productLabel(s.id.split(".")[0], catalog)],
-    parent: screenOf(s.id, ids)
-  }));
-  const byId = new Map(screens.map((s) => [s.id, s]));
-  const screenIds = new Set(ids);
-  for (const c of file.components) {
-    if (screenIds.has(c.id)) {
-      issues.push({ severity: "error", screen: c.id, component: c.id, code: "registry.id-clash", message: `"${c.id}" is both a screen and a component id.` });
-      continue;
-    }
-    const s = screenOf(c.id, ids);
-    if (!s) {
-      issues.push({ severity: "error", screen: "", component: c.id, code: "registry.no-screen", message: `"${c.id}" starts with no registered screen id.` });
-      continue;
-    }
-    byId.get(s).components.push({ bindId: c.id, kind: c.kind, label: c.label, parent: c.parent, info: c.info });
-  }
-  const index = {};
-  for (const b of file.bindings) {
-    const s = screenOf(b.component, ids);
-    if (!s) {
-      issues.push({ severity: "error", screen: "", component: b.component, slot: b.slot, code: "binding.no-screen", message: `Binding for "${b.component}" fits no screen.` });
-      continue;
-    }
-    (index[s] ??= []).push(b);
-  }
-  return {
-    fw: { descriptors: file.kinds, registry: { registryVersion: 1, screens }, catalog, glossaries: file.glossaries },
-    index,
-    issues
-  };
-}
-
 // src/framework/loadCatalog.ts
 import { parse } from "yaml";
 
@@ -269,6 +183,140 @@ function parse2(expr) {
   return parsed;
 }
 
+// src/framework/names.ts
+function humanize(id) {
+  const s = id.replace(/^\$\.?/, "").replace(/\[\*\]/g, "").split(/[./]/).filter(Boolean).pop() ?? id;
+  const w = s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase().trim();
+  return w ? w[0].toUpperCase() + w.slice(1) : id;
+}
+
+// src/framework/file.ts
+var ID = /^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/;
+var BINDING_TYPES = new Set(["operation", "expression", "steps", "none"]);
+function parseBindingsFile(text) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw new Error("The bindings file is not valid JSON.");
+  }
+  return checkBindingsFile(data);
+}
+function checkBindingsFile(data) {
+  const f = data;
+  if (!f || typeof f !== "object")
+    throw new Error("The bindings file must be a JSON object.");
+  if (f.version !== 3)
+    throw new Error(`The bindings file must have "version": 3.`);
+  if (typeof f.openapi !== "string" || !f.openapi)
+    throw new Error(`The bindings file needs "openapi": the docs URL or a path.`);
+  for (const k of ["kinds", "screens", "components", "bindings"])
+    if (!Array.isArray(f[k]))
+      throw new Error(`"${k}" must be a list.`);
+  f.bindings.forEach((b, i) => {
+    const x = b;
+    if (!x || typeof x.component !== "string" || typeof x.slot !== "string" || !BINDING_TYPES.has(x.type))
+      throw new Error(`Binding ${i + 1} needs "component", "slot" and a known "type".`);
+  });
+  if (f.output && (typeof f.output.dir !== "string" || typeof f.output.client !== "string"))
+    throw new Error(`"output" needs "dir" and "client".`);
+  return f;
+}
+var REGISTRY_KEYS = ["kinds", "screens", "components"];
+function parseRegistry(text) {
+  let r;
+  try {
+    r = JSON.parse(text);
+  } catch {
+    throw new Error("The registry file is not valid JSON.");
+  }
+  if (!r || r.version !== 1)
+    throw new Error(`The registry file must have "version": 1.`);
+  if (!Array.isArray(r.kinds) || !Array.isArray(r.screens))
+    throw new Error(`The registry file needs "kinds" and "screens" lists.`);
+  const screens = [];
+  const components = [];
+  const under = (id, owner, what) => {
+    if (typeof id !== "string" || !id)
+      throw new Error(`A ${what} in the registry has no "id".`);
+    if (owner && !id.startsWith(owner + "."))
+      throw new Error(`"${id}" must start with "${owner}.", the id it is nested under.`);
+  };
+  const node = (n, owner, parent) => {
+    under(n.id, owner, "component");
+    if (typeof n.kind !== "string" || typeof n.label !== "string")
+      throw new Error(`"${n.id}" needs "kind" and "label".`);
+    const { children, ...c } = n;
+    components.push(parent ? { ...c, parent } : c);
+    for (const ch of children ?? [])
+      node(ch, n.id, n.id);
+  };
+  const screen = (s, owner) => {
+    under(s.id, owner, "screen");
+    const { components: cs, screens: subs, ...rest } = s;
+    screens.push(rest);
+    for (const c of cs ?? [])
+      node(c, s.id);
+    for (const sub of subs ?? [])
+      screen(sub, s.id);
+  };
+  for (const s of r.screens)
+    screen(s);
+  return { kinds: r.kinds, screens, components };
+}
+function screenOf(id, screens) {
+  let best;
+  for (const s of screens)
+    if (id.startsWith(s + ".") && (!best || s.length > best.length))
+      best = s;
+  return best;
+}
+function productLabel(seg, catalog) {
+  const names = new Set(catalog.operations.map((o) => o.product).filter((p) => !!p));
+  return [...names].find((n) => n.toLowerCase().replace(/[^a-z0-9]+/g, "-") === seg) ?? humanize(seg);
+}
+function fromFile(file, catalog) {
+  const issues = [];
+  const ids = file.screens.map((s) => s.id);
+  const screens = file.screens.map((s) => ({
+    id: s.id,
+    label: s.label,
+    description: s.description,
+    context: s.context ?? [],
+    components: [],
+    path: [productLabel(s.id.split(".")[0], catalog)],
+    parent: screenOf(s.id, ids)
+  }));
+  const byId = new Map(screens.map((s) => [s.id, s]));
+  const screenIds = new Set(ids);
+  for (const c of file.components) {
+    if (screenIds.has(c.id)) {
+      issues.push({ severity: "error", screen: c.id, component: c.id, code: "registry.id-clash", message: `"${c.id}" is both a screen and a component id.` });
+      continue;
+    }
+    const s = screenOf(c.id, ids);
+    if (!s) {
+      issues.push({ severity: "error", screen: "", component: c.id, code: "registry.no-screen", message: `"${c.id}" starts with no registered screen id.` });
+      continue;
+    }
+    byId.get(s).components.push({ bindId: c.id, kind: c.kind, label: c.label, parent: c.parent, info: c.info });
+  }
+  const index = {};
+  for (const b of file.bindings) {
+    const s = screenOf(b.component, ids);
+    if (!s) {
+      issues.push({ severity: "error", screen: "", component: b.component, slot: b.slot, code: "binding.no-screen", message: `Binding for "${b.component}" fits no screen.` });
+      continue;
+    }
+    (index[s] ??= []).push(b);
+  }
+  return {
+    fw: { descriptors: file.kinds, registry: { registryVersion: 1, screens }, catalog, glossaries: file.glossaries },
+    index,
+    issues
+  };
+}
+
 // src/framework/schema.ts
 var obj = (s) => s && typeof s === "object" ? s : {};
 function flat(s) {
@@ -530,11 +578,18 @@ function compileCall(op, request, cx, scope, at) {
   });
   if (op.body) {
     const set = new Set(Object.keys(request).filter((k) => k.startsWith("/body/")).map((k) => decode(k.split("/")[2])));
-    const gaps = whole ? [] : (flat(op.body.schema).required ?? []).filter((f) => !set.has(f));
+    const schema = flat(op.body.schema);
+    const unset = whole ? [] : (schema.required ?? []).filter((f) => !set.has(f));
+    const empty = unset.filter((f) => {
+      const p = flat(schema.properties?.[f]);
+      return p.type === "object" && !p.required?.length;
+    });
+    const gaps = unset.filter((f) => !empty.includes(f));
     if (gaps.length)
       cx.warn("request.required-body", `${op.id} requires ${gaps.join(", ")} in its body; not connected.`, at);
     cx.use.add("assemble");
-    args.push(`assemble(${whole ?? "undefined"}, [${body.join(", ")}])`);
+    const base = whole ?? (empty.length ? `{ ${empty.map((f) => `${prop(f)}: {}`).join(", ")} }` : "undefined");
+    args.push(`assemble(${base}, [${body.join(", ")}])`);
   }
   if (op.parameters.some((p) => p.pointer.startsWith("/query/"))) {
     cx.use.add("defined");
@@ -782,6 +837,30 @@ async function readDocs(src, base) {
     throw new Error(`"${src}" is not a .yaml, .yml or .json file.`);
   return fs.readFile(path.resolve(base, src), "utf8");
 }
+async function readBindings(file) {
+  const text = await fs.readFile(file, "utf8");
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    throw new Error("The bindings file is not valid JSON.");
+  }
+  if (typeof raw?.registry !== "string")
+    return parseBindingsFile(text);
+  const registry = parseRegistry(await fs.readFile(path.resolve(path.dirname(file), raw.registry), "utf8"));
+  return checkBindingsFile({ ...raw, ...registry });
+}
+async function saveBindings(file, merged) {
+  let out = merged;
+  if (merged.registry) {
+    const rest = { ...merged };
+    for (const k of REGISTRY_KEYS)
+      delete rest[k];
+    out = rest;
+  }
+  await writeFileAtomic(file, JSON.stringify(out, null, 2) + `
+`);
+}
 async function writeFileAtomic(file, text) {
   const tmp = `${file}.${process.pid}.tmp`;
   await fs.writeFile(tmp, text, "utf8");
@@ -801,7 +880,7 @@ async function readBody(req, limit = 20 * 1024 * 1024) {
 function send(res, status, body, type = "text/plain; charset=utf-8") {
   res.writeHead(status, { "Content-Type": type, "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" }).end(body);
 }
-function createStudioHandler({ file, prefix, allowed }) {
+function createStudioHandler({ file, prefix, allowed, onSave }) {
   const base = path.dirname(file);
   return async (req, res) => {
     const url = new URL(req.url ?? "/", "http://local");
@@ -819,17 +898,18 @@ function createStudioHandler({ file, prefix, allowed }) {
       }
       if (rel === "/api/bindings") {
         if (req.method === "GET")
-          send(res, 200, await fs.readFile(file, "utf8"), "application/json");
+          send(res, 200, JSON.stringify(await readBindings(file)), "application/json");
         else if (req.method === "PUT") {
-          const text = await readBody(req);
+          let merged;
           try {
-            parseBindingsFile(text);
+            merged = parseBindingsFile(await readBody(req));
           } catch (e) {
             send(res, 400, e.message);
             return true;
           }
-          await writeFileAtomic(file, text);
+          await saveBindings(file, merged);
           send(res, 204, "");
+          onSave?.();
         } else
           send(res, 405, "Method not allowed.");
         return true;
@@ -902,6 +982,38 @@ async function scanIds(dir, file) {
   return issues;
 }
 
+// src/codegen/write.ts
+async function writeScreens(filePath, opts = {}) {
+  const base = path3.dirname(filePath);
+  const file = await readBindings(filePath);
+  const catalog = catalogFromText(await readDocs(file.openapi, base), file.openapi);
+  const { files, issues } = generate(file, catalog);
+  if (opts.src)
+    issues.push(...await scanIds(path3.resolve(opts.src), file));
+  const out = path3.resolve(base, file.output?.dir ?? ".");
+  const result = { issues, out, screens: files.length - 2, changed: [], stale: [] };
+  if (issues.some((i) => i.severity === "error"))
+    return result;
+  await fs3.mkdir(out, { recursive: true });
+  const wanted = new Map(files.map((f) => [path3.join(out, f.path), f.content]));
+  for (const [p, content] of wanted)
+    if (await fs3.readFile(p, "utf8").catch(() => null) !== content)
+      result.changed.push(p);
+  for (const n of await fs3.readdir(out)) {
+    const p = path3.join(out, n);
+    if (n.endsWith(".ts") && !wanted.has(p) && (await fs3.readFile(p, "utf8")).startsWith(`// ${GENERATED_MARK}`))
+      result.stale.push(p);
+  }
+  if (opts.check)
+    return result;
+  for (const p of result.changed)
+    await writeFileAtomic(p, wanted.get(p));
+  for (const p of result.stale)
+    await fs3.unlink(p);
+  return result;
+}
+var describeIssue = (i) => `${i.severity === "error" ? "error  " : "warning"} ${[i.component ?? i.screen, i.slot].filter(Boolean).join(" · ")}: ${i.message}`;
+
 // src/cli/cli.ts
 var HELP = `Usage:
   api-binding studio   [bindings.json] [--port 5180]
@@ -926,54 +1038,31 @@ function args(argv) {
   }
   return { rest, flags };
 }
-function report(issues) {
-  for (const i of issues)
-    console.log(`${i.severity === "error" ? "error  " : "warning"} ${[i.component ?? i.screen, i.slot].filter(Boolean).join(" · ")}: ${i.message}`);
-}
 async function runGenerate(filePath, flags) {
-  const base = path3.dirname(filePath);
-  const file = parseBindingsFile(await fs3.readFile(filePath, "utf8"));
-  const catalog = catalogFromText(await readDocs(file.openapi, base), file.openapi);
-  const { files, issues } = generate(file, catalog);
-  if (typeof flags.src === "string")
-    issues.push(...await scanIds(path3.resolve(flags.src), file));
-  report(issues);
-  const errors = issues.filter((i) => i.severity === "error").length;
+  const r = await writeScreens(filePath, { check: !!flags.check, src: typeof flags.src === "string" ? flags.src : undefined });
+  for (const i of r.issues)
+    console.log(describeIssue(i));
+  const errors = r.issues.filter((i) => i.severity === "error").length;
   if (errors) {
     console.log(`
 ${errors} error(s). Nothing was written.`);
     return 1;
   }
-  const out = path3.resolve(base, file.output.dir);
-  await fs3.mkdir(out, { recursive: true });
-  const wanted = new Map(files.map((f) => [path3.join(out, f.path), f.content]));
-  const existing = (await fs3.readdir(out)).filter((n) => n.endsWith(".ts")).map((n) => path3.join(out, n));
-  const changed = [];
-  const stale = [];
-  for (const [p, content] of wanted)
-    if (await fs3.readFile(p, "utf8").catch(() => null) !== content)
-      changed.push(p);
-  for (const p of existing)
-    if (!wanted.has(p) && (await fs3.readFile(p, "utf8")).startsWith(`// ${GENERATED_MARK}`))
-      stale.push(p);
+  const rel = (p) => path4.relative(process.cwd(), p) || ".";
   if (flags.check) {
-    if (changed.length || stale.length) {
-      console.log(`Out of date: ${[...changed, ...stale].map((p) => path3.relative(process.cwd(), p)).join(", ")}`);
+    if (r.changed.length || r.stale.length) {
+      console.log(`Out of date: ${[...r.changed, ...r.stale].map(rel).join(", ")}`);
       return 1;
     }
     console.log("Generated files are up to date.");
     return 0;
   }
-  for (const p of changed)
-    await writeFileAtomic(p, wanted.get(p));
-  for (const p of stale)
-    await fs3.unlink(p);
-  console.log(`${files.length - 2} screen hook(s) in ${path3.relative(process.cwd(), out) || "."}: ${changed.length} written, ${stale.length} removed.`);
+  console.log(`${r.screens} screen hook(s) in ${rel(r.out)}: ${r.changed.length} written, ${r.stale.length} removed.`);
   return 0;
 }
 async function runStudio(filePath, flags) {
   const port = Number(flags.port ?? 5180);
-  parseBindingsFile(await fs3.readFile(filePath, "utf8"));
+  await readBindings(filePath);
   const origins = new Set([`http://localhost:${port}`, `http://127.0.0.1:${port}`]);
   const allowed = (req) => origins.has(`http://${req.headers.host}`) && (!req.headers.origin || origins.has(String(req.headers.origin)));
   const handle = createStudioHandler({ file: filePath, prefix: "", allowed });
@@ -990,7 +1079,7 @@ Editing ${filePath}. Ctrl+C to stop.`));
 async function main() {
   const [cmd, ...argv] = process.argv.slice(2);
   const { rest, flags } = args(argv);
-  const filePath = path3.resolve(rest[0] ?? "bindings.json");
+  const filePath = path4.resolve(rest[0] ?? "bindings.json");
   if (cmd === "studio")
     return runStudio(filePath, flags);
   if (cmd === "generate")

package/dist/codegen/write.d.ts

@@ -0,0 +1,18 @@
+import type { ValidationIssue } from "../framework/contract";
+export interface WriteResult {
+    issues: ValidationIssue[];
+    /** Directory the hooks go to. */
+    out: string;
+    /** Number of screen hooks generated. */
+    screens: number;
+    /** Files that differ from what is on disk (written unless `check`). */
+    changed: string[];
+    /** Generated files no screen produces any more (removed unless `check`). */
+    stale: string[];
+}
+/** On any error nothing is written. With `check`, nothing is written either; `changed` and `stale` say what is out of date. */
+export declare function writeScreens(filePath: string, opts?: {
+    check?: boolean;
+    src?: string;
+}): Promise<WriteResult>;
+export declare const describeIssue: (i: ValidationIssue) => string;

package/dist/framework/contract.d.ts

@@ -206,10 +206,34 @@ export interface FileScreen extends Labelled {
     id: ScreenId;
     context?: ContextDeclaration[];
 }
-/** The one file that holds everything about API binding: kinds, screens, components, bindings and output. */
+/** A component in the registry tree; `children` are the parts it renders (a grid's columns). */
+export interface RegistryNode {
+    id: BindId;
+    kind: KindId;
+    label: string;
+    info?: Record<string, string>;
+    children?: RegistryNode[];
+}
+/** A screen in the registry tree; `screens` are the sub-screens that open over it (dialogs, drawers). */
+export interface RegistryScreen extends FileScreen {
+    components?: RegistryNode[];
+    screens?: RegistryScreen[];
+}
+/** registry.json: what exists in the app. Every id extends its parent's id. */
+export interface RegistryFile {
+    version: 1;
+    kinds: ComponentDescriptor[];
+    screens: RegistryScreen[];
+}
+/**
+ * The bindings, as the studio and generator see them. On disk, `registry` names registry.json and
+ * the file holds only the rest; kinds, screens and components are read from the registry.
+ */
 export interface BindingsFile {
     $schema?: string;
     version: 3;
+    /** registry.json, relative to this file. */
+    registry?: string;
     /** OpenAPI document: a URL, or a path relative to this file. */
     openapi: string;
     output?: {

package/dist/framework/file.d.ts

@@ -5,6 +5,12 @@ import type { BindingIndex, FrameworkData } from "./engine";
 export declare const ID: RegExp;
 /** Parses and shape-checks a bindings file. Throws a message a person can act on. */
 export declare function parseBindingsFile(text: string): BindingsFile;
+/** Shape-checks a bindings file with its registry already merged in. */
+export declare function checkBindingsFile(data: unknown): BindingsFile;
+/** What the registry contributes to the bindings file; on disk these live only in registry.json. */
+export declare const REGISTRY_KEYS: readonly ["kinds", "screens", "components"];
+/** Parses registry.json and flattens its tree into kinds, screens and components (with `parent`). */
+export declare function parseRegistry(text: string): Pick<BindingsFile, (typeof REGISTRY_KEYS)[number]>;
 /** The screen an id belongs to: the longest screen id that prefixes it. */
 export declare function screenOf(id: string, screens: readonly ScreenId[]): ScreenId | undefined;
 /** Builds the studio's model. Components and bindings that fit no screen are dropped with an issue. */

package/dist/{index-jj8twdw9.js → index-gfw08965.js}

@@ -180,6 +180,9 @@ function parseBindingsFile2(text) {
   } catch {
     throw new Error("The bindings file is not valid JSON.");
   }
+  return checkBindingsFile(data);
+}
+function checkBindingsFile(data) {
   const f = data;
   if (!f || typeof f !== "object")
     throw new Error("The bindings file must be a JSON object.");
@@ -740,5 +743,5 @@ function validateBindings2(engine) {
 
 export { catalogFromOpenApi2, CatalogLoadError2, catalogFromText2, loadCatalog2, humanize, ID2, parseBindingsFile2, screenOf2, fromFile2, toFile2, memoryStore2, httpStore2, flat, createEngine2, validateRegistry2, validateBindings2 };
 
-//# debugId=CBA6673BB224224F64756E2164756E21
-//# sourceMappingURL=index-jj8twdw9.js.map
+//# debugId=548F2EE21986ECDC64756E2164756E21
+//# sourceMappingURL=index-gfw08965.js.map