@exponential_app/engine 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,654 @@
+import {
+  CAPABILITIES2,
+  RESERVED_CAPABILITY_NAMES2,
+  scopeIdValid2,
+  capabilityNameValid2,
+  capabilityDef2,
+  scopeDef2,
+  parseCapabilityCall2,
+  urlOrigin2,
+  brokerDecide2,
+  agentToolList2,
+  brokerAuditRow2
+} from "./chunks/index-tvsykgcv.js";
+import {
+  CONSENT_COPY2,
+  GRANTS_RECORD_VERSION2,
+  consentAnswer2,
+  grantWrite2,
+  grantsRecord2,
+  grantsOnPackage2,
+  consentSheet2,
+  manageSheet2
+} from "./chunks/index-knntt4cb.js";
+import {
+  STOPPED2,
+  lifecycleStep2
+} from "./chunks/index-m2845dn6.js";
+import {
+  PROVIDER_KEYS2,
+  FORBIDDEN_HOST_KEYS2,
+  NETWORK_POLICIES2,
+  IDENTITY_KINDS2,
+  AGENT_PROVIDERS2,
+  validateHostConfig2,
+  engineViewer2,
+  engineRecordRefusal2,
+  networkAllows2
+} from "./chunks/index-sk8b0dh4.js";
+import {
+  outboxWrites2,
+  outboxRequest2,
+  outboxRows2,
+  outboxOutcome2,
+  outboxVerb2,
+  outboxFlush2,
+  outboxReflected2,
+  outboxPrune2,
+  outboxPendingLabel2,
+  outboxMode2
+} from "./chunks/index-v0m7r4y3.js";
+import {
+  wrapLines2,
+  pdfNumber2,
+  pdfImage2,
+  renderPdf2
+} from "./chunks/index-3nf9f7pv.js";
+import {
+  CAPABILITY_TOOLS2,
+  MIME_BY_EXTENSION2,
+  toolDef2,
+  nativeCaller2,
+  schemaViolation2,
+  validateToolArguments2,
+  base64Encode2,
+  base64Decode2,
+  sniffMime2,
+  mimeFor2,
+  newNotificationId2,
+  toolResult2,
+  toolError2,
+  bridgeCall2,
+  pdfFileName2
+} from "./chunks/index-79swfbsm.js";
+import {
+  RUNNER_COPY2,
+  RUNNER_BUNDLE2,
+  RUNNER_SHELL2,
+  runnerConfig2,
+  runnerHasPermissions2,
+  runnerPackage2,
+  runnerFailure2,
+  runnerToast2
+} from "./chunks/index-q4zws02e.js";
+import {
+  StoreError2,
+  applyBatch2,
+  LocalRecordStore2,
+  MemoryPersistence2,
+  MemoryRecordStore2,
+  MemoryVault2,
+  MemoryBlobStore2,
+  localDeviceId2
+} from "./chunks/index-s3xjr701.js";
+// packages/eengine/src/broker.ts
+var refused = (verdict) => ({ refused: { code: verdict.verdict === `unknown` ? `UNKNOWN_TOOL` : `FORBIDDEN`, message: verdict.reason ?? `` } });
+
+class Broker {
+  setup;
+  grantsNow;
+  foreground = false;
+  persisted = Promise.resolve();
+  constructor(setup) {
+    this.setup = setup;
+    this.grantsNow = { ...setup.grants };
+  }
+  get appId() {
+    return this.setup.appId;
+  }
+  get manifest() {
+    return this.setup.manifest;
+  }
+  get capabilities() {
+    return this.setup.capabilities;
+  }
+  grants() {
+    return { ...this.grantsNow };
+  }
+  setForeground(foreground) {
+    this.foreground = foreground;
+  }
+  provided() {
+    return this.setup.capabilities.map((c) => c.name);
+  }
+  record(client, call, verdict, outcome) {
+    this.setup.audit?.record(brokerAuditRow2({ appId: this.setup.appId, client, call, verdict, outcome }));
+  }
+  async run(client, call, verdict) {
+    const capability = this.setup.capabilities.find((c) => c.name === verdict.capability);
+    if (!capability || !verdict.tool) {
+      this.record(client, call, verdict, `unreachable`);
+      return { refused: { code: `FORBIDDEN`, message: `unavailable` } };
+    }
+    const { result, outcome } = await bridgeCall2({
+      tool: `${capability.name}_${verdict.tool}`,
+      arguments: call.arguments ?? {},
+      context: { app: this.setup.appId, screens: this.setup.screens },
+      blobs: this.setup.blobs,
+      native: (tool, args) => capability.call(tool.slice(tool.indexOf(`_`) + 1), args)
+    });
+    this.record(client, call, verdict, outcome);
+    return { result };
+  }
+  call(from, client, name, args) {
+    const call = { from, name, arguments: args };
+    const verdict = brokerDecide2({ manifest: this.setup.manifest, grants: this.grantsNow, provided: this.provided(), foreground: this.foreground, call });
+    if (verdict.verdict === `call`)
+      return this.run(client, call, verdict);
+    if (verdict.verdict === `ask`) {
+      const entry = this.setup.manifest.find((m) => m.id === verdict.scope) ?? { id: verdict.scope ?? ``, why: `` };
+      const { components, data } = consentSheet2(this.setup.appName, entry);
+      return Promise.resolve({ ask: verdict, sheet: { scope: entry.id, components, data } });
+    }
+    this.record(client, call, verdict, null);
+    return Promise.resolve(refused(verdict));
+  }
+  answer(from, client, name, args, verdict, answer) {
+    const call = { from, name, arguments: args };
+    if (!verdict.scope)
+      return Promise.resolve(refused(verdict));
+    const next = consentAnswer2(this.grantsNow, verdict.scope, answer);
+    this.grantsNow = next.grants;
+    this.persist(next.grants);
+    const decided = { ...verdict, verdict: next.verdict, reason: next.reason };
+    if (next.verdict === `call`)
+      return this.run(client, call, decided);
+    this.record(client, call, decided, null);
+    return Promise.resolve(refused(decided));
+  }
+  setGrant(via, gesture, scope, value) {
+    const next = grantWrite2(this.setup.manifest, this.grantsNow, { via, gesture, scope, value });
+    if (next.refused)
+      return next.refused;
+    this.grantsNow = next.grants;
+    this.persist(next.grants);
+    return null;
+  }
+  permissionsSheet() {
+    return manageSheet2(this.setup.manifest, this.grantsNow);
+  }
+  persist(grants) {
+    const { key, value } = grantsRecord2(this.setup.appId, this.setup.signer, this.setup.manifest, grants);
+    this.persisted = this.persisted.then(() => this.setup.vault.write(key, value)).catch(() => {});
+  }
+}
+// packages/eengine/src/instance.ts
+import {
+  kindComputed,
+  kindRefs,
+  kindTransitions,
+  navigateTarget,
+  packageScreens,
+  parseRecordsSource,
+  parseSource,
+  recordPolicy,
+  recordsValue,
+  bridgePackage,
+  validatePackage,
+  verifyPackageFile
+} from "@exponential_app/eui/host";
+class LoadError extends Error {
+  kind;
+  issues;
+  constructor(kind, issues) {
+    super(`${kind}: ${issues.map((i) => `${i.path || `/`} ${i.message}`).join(`; `)}`);
+    this.kind = kind;
+    this.issues = issues;
+    this.name = `LoadError`;
+  }
+}
+var screenKey = (app) => `eengine/screen/${app}`;
+var isObject = (v) => !!v && typeof v === `object` && !Array.isArray(v);
+var packageOf = (file) => isObject(file) && isObject(file.package) ? file.package : file;
+var brokered = (answer) => {
+  if (!(`result` in answer))
+    return answer;
+  const { result } = answer;
+  if (result.isError)
+    return { refused: { code: `failed`, message: result.content[0]?.text ?? `failed` } };
+  return { value: result.structuredContent ?? null };
+};
+var failure = (code, error) => isObject(error) && typeof error.code === `string` && typeof error.message === `string` ? { code: error.code, message: error.message } : { code, message: error instanceof Error ? error.message : String(error) };
+var parseLast = (stored) => {
+  if (!stored)
+    return null;
+  try {
+    const v = JSON.parse(stored);
+    return isObject(v) && typeof v.screen === `string` && isObject(v.params) ? { screen: v.screen, params: v.params } : null;
+  } catch {
+    return null;
+  }
+};
+
+class AppInstance {
+  config;
+  pkg;
+  appId;
+  signer;
+  broker;
+  stateNow = STOPPED2;
+  outboxNow = [];
+  lastScreen;
+  constructor(config, pkg, appId, signer, broker, lastScreen) {
+    this.config = config;
+    this.pkg = pkg;
+    this.appId = appId;
+    this.signer = signer;
+    this.broker = broker;
+    this.lastScreen = lastScreen;
+  }
+  static async load(config, file) {
+    const verification = await verifyPackageFile(file);
+    if (verification.status === `invalid`)
+      throw new LoadError(`signature`, verification.issues);
+    const pkg = bridgePackage(packageOf(file));
+    const issues = validatePackage(pkg);
+    if (issues.length)
+      throw new LoadError(`invalid`, issues);
+    const p = pkg;
+    const appId = typeof p.id === `string` ? p.id : ``;
+    const signer = verification.status === `valid` ? verification.author.key : null;
+    const manifest = Array.isArray(p.capabilities) ? p.capabilities : [];
+    const key = grantsRecord2(appId, signer ?? ``, manifest, {}).key;
+    const [storedGrants, lastScreen] = await Promise.all([config.vault.read(key).catch(() => null), config.vault.read(screenKey(appId)).catch(() => null)]);
+    const broker = new Broker({
+      appId,
+      appName: typeof p.name === `string` ? p.name : appId,
+      signer: signer ?? ``,
+      manifest,
+      grants: grantsOnPackage2(storedGrants, signer ?? ``, manifest),
+      capabilities: config.capabilities,
+      vault: config.vault,
+      blobs: config.blobs,
+      screens: packageScreens(p).map((s) => s.template),
+      audit: config.audit ?? null
+    });
+    return new AppInstance(config, p, appId, signer, broker, lastScreen);
+  }
+  get manifest() {
+    return this.broker.manifest;
+  }
+  grants() {
+    return this.broker.grants();
+  }
+  get state() {
+    return this.stateNow;
+  }
+  get outbox() {
+    return this.outboxNow;
+  }
+  get mode() {
+    return outboxMode2(!!this.config.sync);
+  }
+  me() {
+    return engineViewer2(this.config.identity).id ?? ``;
+  }
+  now() {
+    return this.config.clock?.() ?? new Date().toISOString();
+  }
+  async answerConsent(name, args, verdict, answer) {
+    return brokered(await this.broker.answer(`ui`, null, name, args, verdict, answer));
+  }
+  setGrant(via, gesture, scope, value) {
+    return this.broker.setGrant(via, gesture, scope, value);
+  }
+  permissionsSheet() {
+    return this.broker.permissionsSheet();
+  }
+  async event(event) {
+    const { state, effects } = lifecycleStep2(this.stateNow, event, { pkg: { id: this.appId, screens: this.pkg.screens }, lastScreen: parseLast(this.lastScreen) });
+    this.stateNow = state;
+    this.broker.setForeground(state.phase === `foreground`);
+    for (const effect of effects) {
+      if (effect.effect === `open`)
+        this.config.window.open(this.appId, effect.screen, effect.params, `replace`);
+      else if (effect.effect === `persist`) {
+        this.lastScreen = JSON.stringify({ screen: effect.screen, params: effect.params });
+        await this.config.vault.write(screenKey(this.appId), this.lastScreen).catch(() => {});
+      } else if (effect.effect === `flush`)
+        await this.flush();
+    }
+    return effects;
+  }
+  async recordsValue(source) {
+    const parsed = parseSource(source);
+    const query = parsed ? parseRecordsSource(parsed) : null;
+    if (!query)
+      return;
+    if (query.app !== null)
+      return null;
+    let rows = await this.config.storage.rows(this.appId);
+    if (this.outboxNow.length)
+      rows = outboxRows2(rows, this.outboxNow, this.me());
+    const records = this.pkg.records;
+    const def = query.from && isObject(records) ? records[query.from] : undefined;
+    const viewer = engineViewer2(this.config.identity);
+    return recordsValue(rows, query, {
+      me: viewer.id,
+      now: this.now(),
+      names: {},
+      computed: kindComputed(records, query.from),
+      refs: kindRefs(records, query.from),
+      transitions: kindTransitions(def),
+      role: viewer.role
+    });
+  }
+  subscribe(on) {
+    return this.config.storage.subscribe(this.appId, () => on());
+  }
+  async call(name, args, newIds = []) {
+    const a = isObject(args) ? args : {};
+    switch (name) {
+      case `records_upsert`:
+        return this.write(`upsert`, a, newIds);
+      case `records_delete`:
+        return this.write(`delete`, a, newIds);
+      case `records_batch`:
+        return this.write(`batch`, a, newIds);
+      case `app_navigate`: {
+        const target = navigateTarget(this.pkg, args);
+        if (`error` in target)
+          return { refused: { code: `BAD_REQUEST`, message: target.error } };
+        this.config.window.open(this.appId, target.screen, target.params, `replace`);
+        this.stateNow = { ...this.stateNow, screen: target.screen, params: target.params };
+        return { value: null };
+      }
+      default:
+        return brokered(await this.broker.call(`ui`, null, name, args));
+    }
+  }
+  async refusal(writes) {
+    const rows = await this.config.storage.rows(this.appId).catch(() => []);
+    const records = isObject(this.pkg.records) ? this.pkg.records : {};
+    for (const w of writes) {
+      const row = rows.find((r) => r.id === w.id);
+      const op = w.op;
+      const kind = w.op === `delete` ? row?.kind : w.kind;
+      const policy = recordPolicy(kind ? records[kind] : undefined);
+      const refusal = engineRecordRefusal2(this.config.identity, policy, op, w.op === `create` ? null : row ? { authorId: row.authorId ?? null, createdBy: row.createdBy } : null);
+      if (refusal)
+        return refusal;
+    }
+    return null;
+  }
+  async write(call, args, newIds) {
+    const writes = outboxWrites2(call, args, newIds);
+    const refusal = await this.refusal(writes);
+    if (refusal)
+      return { refused: { code: `FORBIDDEN`, message: refusal } };
+    const entry = { writeId: this.config.newId?.() ?? crypto.randomUUID(), appId: this.appId, call, writes, at: this.now(), state: `pending` };
+    const answer = call === `upsert` ? { id: writes[0]?.id } : call === `delete` ? null : { ids: writes.map((w) => w.id) };
+    if (this.mode === `direct`) {
+      try {
+        await this.config.storage.write(this.appId, batchOf(entry), this.me());
+        return { value: answer };
+      } catch (error) {
+        return { refused: failure(`STORE`, error) };
+      }
+    }
+    this.outboxNow = [...this.outboxNow, entry];
+    if (this.stateNow.phase === `foreground`)
+      await this.flush();
+    return { value: answer };
+  }
+  async flush() {
+    const sync = this.config.sync;
+    if (!sync)
+      return;
+    const results = {};
+    for (const entry of this.outboxNow.filter((e) => e.state === `pending`)) {
+      const { call, input } = outboxRequest2(entry);
+      const result = await sync.push(this.appId, call, input).catch(() => ({ transport: true }));
+      results[entry.writeId] = result;
+      if (outboxOutcome2(entry, result) === `retry`)
+        break;
+    }
+    if (!Object.keys(results).length)
+      return;
+    const now = this.now();
+    const after = outboxFlush2(this.outboxNow, results, now).after;
+    const rows = await this.config.storage.rows(this.appId).catch(() => []);
+    this.outboxNow = outboxPrune2(after, rows, now);
+  }
+}
+function batchOf(entry) {
+  return {
+    writeId: entry.writeId,
+    writes: entry.writes.map((w) => w.op === `delete` ? { op: `delete`, id: w.id } : { op: `upsert`, id: w.id, kind: w.kind, data: w.data, create: w.op === `create` }),
+    at: entry.at
+  };
+}
+function createsOf(name, args) {
+  if (!isObject(args))
+    return 0;
+  if (name === `records_upsert`)
+    return typeof args.id === `string` ? 0 : 1;
+  if (name === `records_batch` && Array.isArray(args.writes))
+    return args.writes.filter((w) => isObject(w) && w.op !== `delete` && typeof w.id !== `string`).length;
+  return 0;
+}
+// packages/eengine/src/synced.ts
+class SyncedRecordStore {
+  log;
+  transport;
+  now;
+  listener;
+  queue;
+  flushing = null;
+  again = false;
+  awaited = new Set;
+  outcomes = new Map;
+  synced = new Map;
+  constructor(log, transport, now, listener, queue) {
+    this.log = log;
+    this.transport = transport;
+    this.now = now;
+    this.listener = listener;
+    this.queue = queue;
+  }
+  static async open(log, transport, now, listener = null) {
+    return new SyncedRecordStore(log, transport, now, listener, await log.entries());
+  }
+  entries() {
+    return [...this.queue];
+  }
+  pendingLabel(app) {
+    return outboxPendingLabel2(this.queue, app);
+  }
+  rows(app) {
+    return this.synced.get(app) ?? [];
+  }
+  visibleRows(app, me) {
+    const entries = this.queue.filter((e) => e.appId === app);
+    return entries.length === 0 ? this.rows(app) : outboxRows2(this.rows(app), entries, me);
+  }
+  async submit(entry, online) {
+    await this.log.push(entry);
+    const awaits = online && !this.queue.some((e) => e.state === `pending`);
+    if (awaits)
+      this.awaited.add(entry.writeId);
+    this.queue.push(entry);
+    this.listener?.changed?.();
+    if (!awaits)
+      return { queued: true };
+    await this.flush();
+    if (this.flushing)
+      await this.flushing;
+    this.awaited.delete(entry.writeId);
+    const outcome = this.outcomes.get(entry.writeId);
+    this.outcomes.delete(entry.writeId);
+    return outcome ?? { queued: true };
+  }
+  async flush() {
+    if (this.flushing) {
+      this.again = true;
+      return;
+    }
+    this.flushing = this.drain().finally(() => {
+      this.flushing = null;
+    });
+    await this.flushing;
+  }
+  async drain() {
+    for (;; ) {
+      const entry = this.queue.find((e) => e.state === `pending`);
+      const stop = entry ? await this.replay(entry) : true;
+      if (!stop)
+        continue;
+      const pending = this.queue.some((e) => e.state === `pending`);
+      const go = this.again && pending;
+      this.again = false;
+      if (!go)
+        return;
+    }
+  }
+  async replay(entry) {
+    const { call, input } = outboxRequest2(entry);
+    const pushed = await this.send(entry.appId, call, input);
+    const outcome = outboxOutcome2(entry, pushed.result);
+    let answer = { queued: true };
+    if (outcome === `done`) {
+      const at = this.now();
+      await this.log.ack(entry.writeId, at);
+      this.queue = this.queue.map((e) => e.writeId === entry.writeId ? { ...e, state: `acked`, ackedAt: at } : e);
+      answer = { done: pushed.answer ?? null };
+    } else if (outcome === `dropped` || outcome === `refused`) {
+      await this.log.remove([entry.writeId]);
+      this.queue = this.queue.filter((e) => e.writeId !== entry.writeId);
+      if (outcome === `refused`)
+        answer = { refused: { message: pushed.message ?? null, invalid: pushed.invalid ?? false } };
+    }
+    if (this.awaited.delete(entry.writeId))
+      this.outcomes.set(entry.writeId, answer);
+    else if (outcome === `refused`)
+      this.listener?.refused?.(entry, outboxVerb2(entry), pushed);
+    if (outcome === `done`)
+      await this.prune();
+    this.listener?.changed?.();
+    return outcome === `retry`;
+  }
+  send(app, call, input) {
+    if (this.transport.send)
+      return this.transport.send(app, call, input);
+    return this.transport.push(app, call, input).then((result) => ({ result }));
+  }
+  async setRows(app, rows) {
+    this.synced.set(app, rows);
+    await this.prune();
+  }
+  async prune() {
+    const now = this.now();
+    const gone = [];
+    for (const app of new Set(this.queue.filter((e) => e.state !== `pending`).map((e) => e.appId))) {
+      const rows = this.synced.get(app);
+      if (!rows)
+        continue;
+      const entries = this.queue.filter((e) => e.appId === app);
+      const kept = new Set(outboxPrune2(entries, rows, now).map((e) => e.writeId));
+      gone.push(...entries.filter((e) => !kept.has(e.writeId)).map((e) => e.writeId));
+    }
+    if (gone.length === 0)
+      return;
+    await this.log.remove(gone);
+    this.queue = this.queue.filter((e) => !gone.includes(e.writeId));
+    this.listener?.changed?.();
+  }
+}
+export {
+  AGENT_PROVIDERS2 as AGENT_PROVIDERS,
+  AppInstance,
+  Broker,
+  CAPABILITIES2 as CAPABILITIES,
+  CAPABILITY_TOOLS2 as CAPABILITY_TOOLS,
+  CONSENT_COPY2 as CONSENT_COPY,
+  FORBIDDEN_HOST_KEYS2 as FORBIDDEN_HOST_KEYS,
+  GRANTS_RECORD_VERSION2 as GRANTS_RECORD_VERSION,
+  IDENTITY_KINDS2 as IDENTITY_KINDS,
+  LoadError,
+  LocalRecordStore2 as LocalRecordStore,
+  MIME_BY_EXTENSION2 as MIME_BY_EXTENSION,
+  MemoryBlobStore2 as MemoryBlobStore,
+  MemoryPersistence2 as MemoryPersistence,
+  MemoryRecordStore2 as MemoryRecordStore,
+  MemoryVault2 as MemoryVault,
+  NETWORK_POLICIES2 as NETWORK_POLICIES,
+  PROVIDER_KEYS2 as PROVIDER_KEYS,
+  RESERVED_CAPABILITY_NAMES2 as RESERVED_CAPABILITY_NAMES,
+  RUNNER_BUNDLE2 as RUNNER_BUNDLE,
+  RUNNER_COPY2 as RUNNER_COPY,
+  RUNNER_SHELL2 as RUNNER_SHELL,
+  STOPPED2 as STOPPED,
+  StoreError2 as StoreError,
+  SyncedRecordStore,
+  agentToolList2 as agentToolList,
+  applyBatch2 as applyBatch,
+  base64Decode2 as base64Decode,
+  base64Encode2 as base64Encode,
+  batchOf,
+  bridgeCall2 as bridgeCall,
+  brokerAuditRow2 as brokerAuditRow,
+  brokerDecide2 as brokerDecide,
+  capabilityDef2 as capabilityDef,
+  capabilityNameValid2 as capabilityNameValid,
+  consentAnswer2 as consentAnswer,
+  consentSheet2 as consentSheet,
+  createsOf,
+  engineRecordRefusal2 as engineRecordRefusal,
+  engineViewer2 as engineViewer,
+  grantWrite2 as grantWrite,
+  grantsOnPackage2 as grantsOnPackage,
+  grantsRecord2 as grantsRecord,
+  lifecycleStep2 as lifecycleStep,
+  localDeviceId2 as localDeviceId,
+  manageSheet2 as manageSheet,
+  mimeFor2 as mimeFor,
+  nativeCaller2 as nativeCaller,
+  networkAllows2 as networkAllows,
+  newNotificationId2 as newNotificationId,
+  outboxFlush2 as outboxFlush,
+  outboxMode2 as outboxMode,
+  outboxOutcome2 as outboxOutcome,
+  outboxPendingLabel2 as outboxPendingLabel,
+  outboxPrune2 as outboxPrune,
+  outboxReflected2 as outboxReflected,
+  outboxRequest2 as outboxRequest,
+  outboxRows2 as outboxRows,
+  outboxVerb2 as outboxVerb,
+  outboxWrites2 as outboxWrites,
+  packageOf,
+  parseCapabilityCall2 as parseCapabilityCall,
+  pdfFileName2 as pdfFileName,
+  pdfImage2 as pdfImage,
+  pdfNumber2 as pdfNumber,
+  renderPdf2 as renderPdf,
+  runnerConfig2 as runnerConfig,
+  runnerFailure2 as runnerFailure,
+  runnerHasPermissions2 as runnerHasPermissions,
+  runnerPackage2 as runnerPackage,
+  runnerToast2 as runnerToast,
+  schemaViolation2 as schemaViolation,
+  scopeDef2 as scopeDef,
+  scopeIdValid2 as scopeIdValid,
+  screenKey,
+  sniffMime2 as sniffMime,
+  toolDef2 as toolDef,
+  toolError2 as toolError,
+  toolResult2 as toolResult,
+  urlOrigin2 as urlOrigin,
+  validateHostConfig2 as validateHostConfig,
+  validateToolArguments2 as validateToolArguments,
+  wrapLines2 as wrapLines
+};
+
+//# debugId=4B8F99E4043BD1B764756E2164756E21
+//# sourceMappingURL=index.js.map