@byearlybird/starling 0.1.2

package/dist/index.js

@@ -0,0 +1,454 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// lib/core/crdt/operations.ts
+function encode(obj, eventstamp) {
+  const result = {};
+  function step(target, output) {
+    for (const key in target) {
+      if (!Object.hasOwn(target, key))
+        continue;
+      const value = target[key];
+      if (value != null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype) {
+        output[key] = {};
+        step(value, output[key]);
+      } else {
+        output[key] = {
+          __value: value,
+          __eventstamp: eventstamp
+        };
+      }
+    }
+  }
+  step(obj, result);
+  return result;
+}
+function decode(obj) {
+  const result = {};
+  function step(source, output) {
+    for (const key in source) {
+      if (!Object.hasOwn(source, key))
+        continue;
+      if (key === "__deleted")
+        continue;
+      const value = source[key];
+      if (value && "__value" in value && "__eventstamp" in value) {
+        output[key] = value.__value;
+      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        output[key] = {};
+        step(value, output[key]);
+      }
+    }
+  }
+  step(obj, result);
+  return result;
+}
+function merge(obj1, obj2) {
+  const result = {};
+  let changed = false;
+  function isEncodedValue(val) {
+    return val != null && typeof val === "object" && "__value" in val && "__eventstamp" in val;
+  }
+  function step(v1, v2, output) {
+    for (const key in v1) {
+      if (!Object.hasOwn(v1, key))
+        continue;
+      const value1 = v1[key];
+      const value2 = v2[key];
+      if (isEncodedValue(value1) && isEncodedValue(value2)) {
+        if (value1.__eventstamp >= value2.__eventstamp) {
+          output[key] = value1;
+        } else {
+          output[key] = value2;
+          changed = true;
+        }
+      } else if (isEncodedValue(value1)) {
+        output[key] = value1;
+      } else if (value1 && value2 && typeof value1 === "object" && typeof value2 === "object") {
+        output[key] = {};
+        step(value1, value2, output[key]);
+      } else if (value1) {
+        output[key] = value1;
+      }
+    }
+    for (const key in v2) {
+      if (!Object.hasOwn(v2, key) || Object.hasOwn(result, key))
+        continue;
+      const value = v2[key];
+      if (value) {
+        output[key] = value;
+        changed = true;
+      }
+    }
+  }
+  step(obj1, obj2, result);
+  return [result, changed];
+}
+function mergeArray(current, updates) {
+  const updatesMap = new Map(updates.map((item) => [item.key, item.value]));
+  const result = [];
+  let changed = false;
+  const seenKeys = new Set;
+  for (const { key, value: obj1 } of current) {
+    seenKeys.add(key);
+    const obj2 = updatesMap.get(key);
+    if (obj2) {
+      const [merged, objChanged] = merge(obj1, obj2);
+      result.push({ key, value: merged });
+      if (objChanged) {
+        changed = true;
+      }
+    } else {
+      result.push({ key, value: obj1 });
+    }
+  }
+  for (const { key, value: obj2 } of updates) {
+    if (!seenKeys.has(key)) {
+      result.push({ key, value: obj2 });
+      changed = true;
+    }
+  }
+  return [result, changed];
+}
+var encodeMany = (data, eventstampFn) => data.map(({ key, value }) => ({ key, value: encode(value, eventstampFn()) }));
+// lib/core/crdt/clock.ts
+var formatEventstamp = (timestampMs, counter) => {
+  const isoString = new Date(timestampMs).toISOString();
+  return `${isoString}|${counter.toString(16).padStart(8, "0")}`;
+};
+var parseEventstamp = (eventstamp) => {
+  const pipeIndex = eventstamp.indexOf("|");
+  const isoString = eventstamp.slice(0, pipeIndex);
+  const hexCounter = eventstamp.slice(pipeIndex + 1);
+  return {
+    timestampMs: new Date(isoString).getTime(),
+    counter: parseInt(hexCounter, 16)
+  };
+};
+var createClock = () => {
+  let counter = 0;
+  let lastMs = Date.now();
+  return {
+    now() {
+      const nowMs = Date.now();
+      if (nowMs <= lastMs) {
+        counter++;
+      } else {
+        lastMs = nowMs;
+        counter = 0;
+      }
+      return formatEventstamp(nowMs, counter);
+    },
+    latest() {
+      return formatEventstamp(lastMs, counter);
+    },
+    forward(eventstamp) {
+      const latest = this.latest();
+      if (eventstamp > latest) {
+        const newer = parseEventstamp(eventstamp);
+        lastMs = newer.timestampMs;
+        counter = newer.counter;
+      }
+    }
+  };
+};
+
+// lib/core/shared/utils.ts
+function mapToArray(map) {
+  return Array.from(map.entries()).map(([key, value]) => ({ key, value }));
+}
+var mergeItems = (map, items) => {
+  const merged = [];
+  for (const { key, value } of items) {
+    const current = map.get(key);
+    if (!current)
+      continue;
+    const [mergedValue, changed] = merge(current, value);
+    if (changed) {
+      merged.push({ key, value: mergedValue });
+    }
+  }
+  return merged;
+};
+
+// node_modules/.bun/mitt@3.0.1/node_modules/mitt/dist/mitt.mjs
+function mitt_default(n) {
+  return { all: n = n || new Map, on: function(t, e) {
+    var i = n.get(t);
+    i ? i.push(e) : n.set(t, [e]);
+  }, off: function(t, e) {
+    var i = n.get(t);
+    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
+  }, emit: function(t, e) {
+    var i = n.get(t);
+    i && i.slice().map(function(n2) {
+      n2(e);
+    }), (i = n.get("*")) && i.slice().map(function(n2) {
+      n2(t, e);
+    });
+  } };
+}
+
+// lib/core/store/mutations.ts
+var createPutMany = (map, clock, emitter) => {
+  return (data) => {
+    encodeMany(data, () => clock.now()).forEach(({ key, value }) => {
+      map.set(key, value);
+    });
+    emitter.emit("put", data);
+  };
+};
+var createUpdateMany = (map, clock, emitter) => {
+  return (data) => {
+    const validData = data.filter((d) => map.has(d.key));
+    if (validData.length === 0)
+      return;
+    const updateEvents = [];
+    let anyChanged = false;
+    for (const { key, value } of validData) {
+      const current = map.get(key);
+      if (!current)
+        continue;
+      const encoded = encode(value, clock.now());
+      const [mergedValue, itemChanged] = merge(current, encoded);
+      if (itemChanged) {
+        map.set(key, mergedValue);
+        updateEvents.push({ key, value: decode(mergedValue) });
+        anyChanged = true;
+      }
+    }
+    if (!anyChanged)
+      return;
+    emitter.emit("update", updateEvents);
+  };
+};
+var createDeleteMany = (map, clock, emitter) => {
+  return (keys) => {
+    const validKeys = keys.filter((key) => map.has(key));
+    if (validKeys.length === 0)
+      return;
+    const deletionMarkers = encodeMany(validKeys.map((key) => ({ key, value: { __deleted: true } })), () => clock.now());
+    const merged = mergeItems(map, deletionMarkers);
+    if (merged.length === 0)
+      return;
+    const deleteEvents = [];
+    merged.forEach(({ key, value }) => {
+      map.set(key, value);
+      deleteEvents.push({ key });
+    });
+    emitter.emit("delete", deleteEvents);
+  };
+};
+var createMerge = (map, emitter) => {
+  return (snapshot, opts = { silent: false }) => {
+    const putEvents = [];
+    const updateEvents = [];
+    const deleteEvents = [];
+    for (const { key, value: snapshotValue } of snapshot) {
+      const currentValue = map.get(key);
+      if (!currentValue) {
+        putEvents.push({ key, value: decode(snapshotValue) });
+        map.set(key, snapshotValue);
+      } else {
+        const [mergedValue, changed] = merge(currentValue, snapshotValue);
+        if (changed) {
+          const wasDeleted = currentValue.__deleted !== undefined;
+          const isDeleted = mergedValue.__deleted !== undefined;
+          if (!wasDeleted && isDeleted) {
+            map.set(key, mergedValue);
+            deleteEvents.push({ key });
+          } else {
+            map.set(key, mergedValue);
+            updateEvents.push({ key, value: decode(mergedValue) });
+          }
+        }
+      }
+    }
+    if (opts.silent)
+      return;
+    if (putEvents.length > 0) {
+      emitter.emit("put", putEvents);
+    }
+    if (updateEvents.length > 0) {
+      emitter.emit("update", updateEvents);
+    }
+    if (deleteEvents.length > 0) {
+      emitter.emit("delete", deleteEvents);
+    }
+  };
+};
+
+// lib/core/store/query.ts
+var createQuery = (map, queries) => {
+  return (predicate) => {
+    const results = new Map;
+    for (const [key, rawValue] of map.entries()) {
+      const value = decode(rawValue);
+      if (predicate(value)) {
+        results.set(key, value);
+      }
+    }
+    const internal = {
+      predicate,
+      results,
+      callbacks: new Set
+    };
+    queries.add(internal);
+    return {
+      results() {
+        return results;
+      },
+      onChange: (callback) => {
+        internal.callbacks.add(callback);
+        return () => {
+          internal.callbacks.delete(callback);
+        };
+      },
+      dispose: () => {
+        internal.callbacks.clear();
+        queries.delete(internal);
+      }
+    };
+  };
+};
+
+// lib/core/store/store.ts
+var createStore = (collectionKey) => {
+  const $map = new Map;
+  const $emitter = mitt_default();
+  const $clock = createClock();
+  const $handles = new Set;
+  const $queries = new Set;
+  $emitter.on("*", (event) => {
+    if (event === "change")
+      return;
+    $emitter.emit("change");
+  });
+  const runCallbacks = (dirtyQueries) => {
+    for (const query2 of dirtyQueries) {
+      for (const callback of query2.callbacks) {
+        callback();
+      }
+    }
+    dirtyQueries.clear();
+  };
+  $emitter.on("put", (data) => {
+    const dirtyQueries = new Set;
+    for (const query2 of $queries) {
+      for (const item of data) {
+        if (query2.predicate(item.value)) {
+          query2.results.set(item.key, item.value);
+          dirtyQueries.add(query2);
+        }
+      }
+    }
+    runCallbacks(dirtyQueries);
+  });
+  $emitter.on("delete", (data) => {
+    const dirtyQueries = new Set;
+    for (const query2 of $queries) {
+      for (const item of data) {
+        if (query2.results.has(item.key)) {
+          query2.results.delete(item.key);
+          dirtyQueries.add(query2);
+        }
+      }
+    }
+    runCallbacks(dirtyQueries);
+  });
+  $emitter.on("update", (data) => {
+    const dirtyQueries = new Set;
+    for (const query2 of $queries) {
+      for (const item of data) {
+        const matches = query2.predicate(item.value);
+        const inResults = query2.results.has(item.key);
+        if (matches) {
+          query2.results.set(item.key, item.value);
+          dirtyQueries.add(query2);
+        } else if (inResults) {
+          query2.results.delete(item.key);
+          dirtyQueries.add(query2);
+        }
+      }
+    }
+    runCallbacks(dirtyQueries);
+  });
+  const putMany = createPutMany($map, $clock, $emitter);
+  const updateMany = createUpdateMany($map, $clock, $emitter);
+  const deleteMany = createDeleteMany($map, $clock, $emitter);
+  const merge2 = createMerge($map, $emitter);
+  const query = createQuery($map, $queries);
+  return {
+    collectionKey,
+    putMany,
+    updateMany,
+    deleteMany,
+    merge: merge2,
+    put(key, value) {
+      this.putMany([{ key, value }]);
+    },
+    update(key, value) {
+      this.updateMany([{ key, value }]);
+    },
+    delete(key) {
+      this.deleteMany([key]);
+    },
+    values() {
+      const result = [];
+      for (const [key, value] of $map) {
+        if (!value.__deleted) {
+          result.push({ key, value: decode(value) });
+        }
+      }
+      return result;
+    },
+    query,
+    snapshot() {
+      return mapToArray($map);
+    },
+    on(event, callback) {
+      $emitter.on(event, callback);
+      return () => {
+        $emitter.off(event, callback);
+      };
+    },
+    use(plugin) {
+      $handles.add(plugin(this));
+      return this;
+    },
+    async init() {
+      for (const handle of $handles) {
+        await handle.init();
+      }
+      return this;
+    },
+    async dispose() {
+      $handles.forEach(async (handle) => {
+        await handle.dispose();
+      });
+      $emitter.all.clear();
+    }
+  };
+};
+export {
+  mergeArray,
+  merge,
+  encode,
+  decode,
+  createStore
+};

package/dist/plugins/index.d.ts

@@ -0,0 +1,3 @@
+export { pushPullPlugin } from "./push-pull-plugin";
+export { unstoragePlugin } from "./unstorage-plugin";
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/plugins/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/plugins/index.js

@@ -0,0 +1,188 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// lib/plugins/push-pull-plugin.ts
+var pushPullPlugin = (config) => {
+  const {
+    push,
+    pull,
+    preprocess,
+    pullInterval = 1000 * 60 * 5,
+    immediate = true
+  } = config;
+  const plugin = (store) => {
+    let intervalId = null;
+    let unwatch = null;
+    async function pullData() {
+      const data = await pull();
+      const processed = preprocess ? await preprocess("pull", data) : data;
+      store.merge(processed);
+    }
+    async function pushData(data) {
+      const processed = preprocess ? await preprocess("push", data) : data;
+      await push(processed);
+    }
+    return {
+      init: async () => {
+        unwatch = store.on("change", async () => {
+          const latest = store.snapshot();
+          if (latest.length > 0) {
+            await pushData(latest);
+          }
+        });
+        if (immediate)
+          await pullData();
+        intervalId = setInterval(pullData, pullInterval);
+      },
+      dispose: async () => {
+        if (intervalId !== null) {
+          clearInterval(intervalId);
+          intervalId = null;
+        }
+        unwatch?.();
+      }
+    };
+  };
+  return plugin;
+};
+// node_modules/.bun/unstorage@1.17.1/node_modules/unstorage/dist/shared/unstorage.zVDD2mZo.mjs
+var storageKeyProperties = [
+  "has",
+  "hasItem",
+  "get",
+  "getItem",
+  "getItemRaw",
+  "set",
+  "setItem",
+  "setItemRaw",
+  "del",
+  "remove",
+  "removeItem",
+  "getMeta",
+  "setMeta",
+  "removeMeta",
+  "getKeys",
+  "clear",
+  "mount",
+  "unmount"
+];
+function prefixStorage(storage, base) {
+  base = normalizeBaseKey(base);
+  if (!base) {
+    return storage;
+  }
+  const nsStorage = { ...storage };
+  for (const property of storageKeyProperties) {
+    nsStorage[property] = (key = "", ...args) => storage[property](base + key, ...args);
+  }
+  nsStorage.getKeys = (key = "", ...arguments_) => storage.getKeys(base + key, ...arguments_).then((keys) => keys.map((key2) => key2.slice(base.length)));
+  nsStorage.keys = nsStorage.getKeys;
+  nsStorage.getItems = async (items, commonOptions) => {
+    const prefixedItems = items.map((item) => typeof item === "string" ? base + item : { ...item, key: base + item.key });
+    const results = await storage.getItems(prefixedItems, commonOptions);
+    return results.map((entry) => ({
+      key: entry.key.slice(base.length),
+      value: entry.value
+    }));
+  };
+  nsStorage.setItems = async (items, commonOptions) => {
+    const prefixedItems = items.map((item) => ({
+      key: base + item.key,
+      value: item.value,
+      options: item.options
+    }));
+    return storage.setItems(prefixedItems, commonOptions);
+  };
+  return nsStorage;
+}
+function normalizeKey(key) {
+  if (!key) {
+    return "";
+  }
+  return key.split("?")[0]?.replace(/[/\\]/g, ":").replace(/:+/g, ":").replace(/^:|:$/g, "") || "";
+}
+function normalizeBaseKey(base) {
+  base = normalizeKey(base);
+  return base ? base + ":" : "";
+}
+
+// node_modules/.bun/unstorage@1.17.1/node_modules/unstorage/dist/index.mjs
+function defineDriver(factory) {
+  return factory;
+}
+var DRIVER_NAME = "memory";
+var memory = defineDriver(() => {
+  const data = /* @__PURE__ */ new Map;
+  return {
+    name: DRIVER_NAME,
+    getInstance: () => data,
+    hasItem(key) {
+      return data.has(key);
+    },
+    getItem(key) {
+      return data.get(key) ?? null;
+    },
+    getItemRaw(key) {
+      return data.get(key) ?? null;
+    },
+    setItem(key, value) {
+      data.set(key, value);
+    },
+    setItemRaw(key, value) {
+      data.set(key, value);
+    },
+    removeItem(key) {
+      data.delete(key);
+    },
+    getKeys() {
+      return [...data.keys()];
+    },
+    clear() {
+      data.clear();
+    },
+    dispose() {
+      data.clear();
+    }
+  };
+});
+
+// lib/plugins/unstorage-plugin.ts
+var unstoragePlugin = (baseStorage) => {
+  let unwatch = null;
+  let storage = null;
+  const plugin = (store) => ({
+    init: async () => {
+      storage = prefixStorage(baseStorage, store.collectionKey);
+      unwatch = store.on("change", async () => {
+        await storage?.set(store.collectionKey, store.snapshot());
+      });
+      const persisted = await storage.get(store.collectionKey);
+      if (persisted) {
+        store.merge(persisted, { silent: true });
+      }
+    },
+    dispose: () => {
+      unwatch?.();
+    }
+  });
+  return plugin;
+};
+export {
+  unstoragePlugin,
+  pushPullPlugin
+};

package/dist/plugins/persistence/index.d.ts

@@ -0,0 +1,2 @@
+export { unstoragePlugin } from "../unstorage-plugin";
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/persistence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/plugins/persistence/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/plugins/persistence/unstorage-plugin.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "@core/store/store";
+import { type Storage } from "unstorage";
+declare const unstoragePlugin: <T extends object>(baseStorage: Storage) => Plugin<T>;
+export { unstoragePlugin };
+//# sourceMappingURL=unstorage-plugin.d.ts.map

package/dist/plugins/persistence/unstorage-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unstorage-plugin.d.ts","sourceRoot":"","sources":["../../../lib/plugins/persistence/unstorage-plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAExD,QAAA,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,EAAE,aAAa,OAAO,KAAG,MAAM,CAAC,CAAC,CAyBzE,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/plugins/push-pull-plugin.d.ts

@@ -0,0 +1,13 @@
+import type { ArrayKV, EncodedObject } from "@core/shared/types";
+import type { Plugin } from "@core/store/store";
+type PushPullConfig = {
+    push: (data: ArrayKV<EncodedObject>) => Promise<void>;
+    pull: () => Promise<ArrayKV<EncodedObject>>;
+    pullInterval?: number;
+    preprocess?: (event: "pull" | "push", data: ArrayKV<EncodedObject>) => Promise<ArrayKV<EncodedObject>>;
+    immediate?: boolean;
+};
+declare const pushPullPlugin: <TValue extends object>(config: PushPullConfig) => Plugin<TValue>;
+export { pushPullPlugin };
+export type { PushPullConfig };
+//# sourceMappingURL=push-pull-plugin.d.ts.map

package/dist/plugins/push-pull-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push-pull-plugin.d.ts","sourceRoot":"","sources":["../../lib/plugins/push-pull-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,KAAK,cAAc,GAAG;IACrB,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,aAAa,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC;IAC5C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,CACZ,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,IAAI,EAAE,OAAO,CAAC,aAAa,CAAC,KACxB,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC;IACrC,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,QAAA,MAAM,cAAc,GAAI,MAAM,SAAS,MAAM,EAC5C,QAAQ,cAAc,KACpB,MAAM,CAAC,MAAM,CAiDf,CAAC;AAEF,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,YAAY,EAAE,cAAc,EAAE,CAAC"}

package/dist/plugins/sync/index.d.ts

@@ -0,0 +1,3 @@
+export type { PushPullConfig } from "./push-pull-plugin";
+export { pushPullPlugin } from "./push-pull-plugin";
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/sync/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/plugins/sync/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}