ts-patch-mongoose 3.1.2 → 4.0.0

package/README.md

@@ -12,6 +12,10 @@ Patch history (audit log) & events plugin for mongoose
 [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=ilovepixelart_ts-patch-mongoose&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=ilovepixelart_ts-patch-mongoose)
 [![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=ilovepixelart_ts-patch-mongoose&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=ilovepixelart_ts-patch-mongoose)
 [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=ilovepixelart_ts-patch-mongoose&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=ilovepixelart_ts-patch-mongoose)
+\
+[![Socket Badge](https://badge.socket.dev/npm/package/ts-patch-mongoose)](https://socket.dev/npm/package/ts-patch-mongoose)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/ilovepixelart/ts-patch-mongoose/badge)](https://securityscorecards.dev/viewer/?uri=github.com/ilovepixelart/ts-patch-mongoose)
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12473/badge)](https://www.bestpractices.dev/en/projects/12473)
 
 ## Motivation
 
@@ -24,10 +28,12 @@ I need to track changes of mongoose models and save them as patch history (audit
 ```json
 {
   "node": "20.x || 22.x || 24.x",
-  "mongoose": ">=6.6.0 || 7.x || 8.x || 9.x",
+  "mongoose": ">=6.6.0 <10"
 }
 ```
 
+CI tests against mongoose `6.12.2`, `7.6.4`, `8.23.0`, and `9.4.1`.
+
 ## Features
 
 - Track changes in mongoose models
@@ -109,12 +115,12 @@ const BookSchema = new Schema<Book>({
   }
 }, { timestamps: true })
 
-BookSchema.plugin(patchHistoryPlugin, { 
+BookSchema.plugin(patchHistoryPlugin, {
   // Provide your event constants to plugin
   eventCreated: BOOK_CREATED,
   eventUpdated: BOOK_UPDATED,
   eventDeleted: BOOK_DELETED,
-  
+
   // You can omit some properties in case you don't want to save them to patch history
   omit: ['__v', 'createdAt', 'updatedAt'],
 

package/dist/index.cjs

@@ -1,9 +1,7 @@
 'use strict';
 
 var mongoose = require('mongoose');
-var jsonpatch = require('fast-json-patch');
 var EventEmitter = require('node:events');
-var powerAssign = require('power-assign');
 
 const HistorySchema = new mongoose.Schema(
   {
@@ -250,6 +248,94 @@ class PatchEventEmitter extends EventEmitter {
 }
 const em = new PatchEventEmitter();
 
+const escapeToken = (key) => {
+  if (!key.includes("/") && !key.includes("~")) return key;
+  return key.replaceAll("~", "~0").replaceAll("/", "~1");
+};
+const joinPath = (base, key) => `${base}/${escapeToken(key)}`;
+const cloneValue = (value) => {
+  if (value === void 0) return null;
+  if (value === null || typeof value !== "object") return value;
+  return JSON.parse(JSON.stringify(value));
+};
+const isContainer = (value) => {
+  return typeof value === "object" && value !== null;
+};
+const keysOf = (value) => {
+  if (Array.isArray(value)) {
+    const indices = [];
+    for (let i = 0; i < value.length; i++) indices.push(String(i));
+    return indices;
+  }
+  return Object.keys(value);
+};
+const normalizeTarget = (target) => {
+  if (!isContainer(target) || Array.isArray(target)) return target;
+  const withToJSON = target;
+  return typeof withToJSON.toJSON === "function" ? withToJSON.toJSON() : target;
+};
+const emitTest = (path, value, invertible, out) => {
+  if (invertible) out.push({ op: "test", path, value: cloneValue(value) });
+};
+const emitReplace = (path, source, target, invertible, out) => {
+  emitTest(path, source, invertible, out);
+  out.push({ op: "replace", path, value: cloneValue(target) });
+};
+const emitRemove = (path, source, invertible, out) => {
+  emitTest(path, source, invertible, out);
+  out.push({ op: "remove", path });
+};
+const shouldTreatAsRemoval = (sourceChild, targetChild, sourceIsArray) => {
+  return targetChild === void 0 && sourceChild !== void 0 && !sourceIsArray;
+};
+const diffSourceKey = (scope, key) => {
+  const { source, target, targetKeySet, basePath, sourceIsArray, invertible, out } = scope;
+  const childPath = joinPath(basePath, key);
+  const sourceChild = source[key];
+  if (!targetKeySet.has(key)) {
+    emitRemove(childPath, sourceChild, invertible, out);
+    return;
+  }
+  const targetChild = target[key];
+  if (shouldTreatAsRemoval(sourceChild, targetChild, sourceIsArray)) {
+    emitRemove(childPath, sourceChild, invertible, out);
+    return;
+  }
+  diff(sourceChild, targetChild, childPath, invertible, out);
+};
+const diffAddedKeys = (target, sourceKeys, targetKeys, basePath, out) => {
+  const sourceKeySet = new Set(sourceKeys);
+  for (const key of targetKeys) {
+    if (sourceKeySet.has(key)) continue;
+    const targetChild = target[key];
+    if (targetChild === void 0) continue;
+    out.push({ op: "add", path: joinPath(basePath, key), value: cloneValue(targetChild) });
+  }
+};
+const diff = (source, target, basePath, invertible, out) => {
+  if (source === target) return;
+  const resolvedTarget = normalizeTarget(target);
+  const sourceIsArray = Array.isArray(source);
+  const targetIsArray = Array.isArray(resolvedTarget);
+  if (!isContainer(source) || !isContainer(resolvedTarget) || sourceIsArray !== targetIsArray) {
+    emitReplace(basePath, source, resolvedTarget, invertible, out);
+    return;
+  }
+  const sourceKeys = keysOf(source);
+  const targetKeys = keysOf(resolvedTarget);
+  const targetKeySet = new Set(targetKeys);
+  const scope = { source, target: resolvedTarget, targetKeySet, basePath, sourceIsArray, invertible, out };
+  for (const key of Array.from(sourceKeys).reverse()) {
+    diffSourceKey(scope, key);
+  }
+  diffAddedKeys(resolvedTarget, sourceKeys, targetKeys, basePath, out);
+};
+const compare = (source, target, invertible = false) => {
+  const out = [];
+  diff(source, target, "", invertible, out);
+  return out;
+};
+
 const isPlainObject = (val) => {
   if (Object.prototype.toString.call(val) !== "[object Object]") return false;
   const prot = Object.getPrototypeOf(val);
@@ -380,7 +466,7 @@ const updatePatch = async (opts, context, current, original) => {
   const currentObject = getJsonOmit(opts, current);
   const originalObject = getJsonOmit(opts, original);
   if (isEmpty(originalObject) || isEmpty(currentObject)) return;
-  const patch = jsonpatch.compare(originalObject, currentObject, true);
+  const patch = compare(originalObject, currentObject, true);
   if (isEmpty(patch)) return;
   emitEvent(context, opts.eventUpdated, { oldDoc: original, doc: current, patch });
   if (history) {
@@ -469,6 +555,186 @@ const saveHooksInitialize = (schema, opts) => {
   });
 };
 
+const hasOwn = Object.prototype.hasOwnProperty;
+const parseSegment = (segment) => {
+  const asNumber2 = Number(segment);
+  return Number.isInteger(asNumber2) && String(asNumber2) === segment ? asNumber2 : segment;
+};
+const parsePath = (path) => {
+  const [first, ...rest] = path.split(".").map(parseSegment);
+  let leaf = first ?? path;
+  const crumbs = [];
+  for (const key of rest) {
+    crumbs.push({ key: leaf, nextNumeric: typeof key === "number" });
+    leaf = key;
+  }
+  return { leaf, crumbs };
+};
+const deepEqualJson = (a, b) => {
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return a === b;
+  }
+};
+const ensureContainer = (parent, key, hintNumeric) => {
+  const existing = parent[key];
+  if (existing !== null && typeof existing === "object") {
+    return existing;
+  }
+  const created = hintNumeric ? [] : {};
+  parent[key] = created;
+  return created;
+};
+const setAtPath = (doc, path, value) => {
+  const { leaf, crumbs } = parsePath(path);
+  let cursor = doc;
+  for (const crumb of crumbs) {
+    cursor = ensureContainer(cursor, crumb.key, crumb.nextNumeric);
+  }
+  cursor[leaf] = value;
+};
+const getAtPath = (doc, path) => {
+  const { leaf, crumbs } = parsePath(path);
+  let cursor = doc;
+  for (const crumb of crumbs) {
+    const next = cursor[crumb.key];
+    if (next === null || typeof next !== "object") return void 0;
+    cursor = next;
+  }
+  return { container: cursor, leaf, exists: hasOwn.call(cursor, leaf) };
+};
+const unsetAtPath = (doc, path) => {
+  const located = getAtPath(doc, path);
+  if (!located) return;
+  if (Array.isArray(located.container)) {
+    located.container[located.leaf] = void 0;
+  } else {
+    delete located.container[located.leaf];
+  }
+};
+const asNumber = (value) => typeof value === "number" ? value : 0;
+const toArray = (value) => Array.isArray(value) ? value : void 0;
+const shouldReplaceForMin = (current, candidate) => {
+  if (candidate === void 0) return false;
+  if (current === void 0) return true;
+  return candidate < current;
+};
+const shouldReplaceForMax = (current, candidate) => {
+  if (candidate === void 0) return false;
+  if (current === void 0) return true;
+  return candidate > current;
+};
+const operators = {
+  $set: (doc, path, value) => setAtPath(doc, path, value),
+  $unset: (doc, path) => unsetAtPath(doc, path),
+  $inc: (doc, path, delta) => {
+    const located = getAtPath(doc, path);
+    const current = located?.exists ? asNumber(located.container[located.leaf]) : 0;
+    setAtPath(doc, path, current + asNumber(delta));
+  },
+  $mul: (doc, path, factor) => {
+    const located = getAtPath(doc, path);
+    const current = located?.exists ? asNumber(located.container[located.leaf]) : 0;
+    setAtPath(doc, path, current * asNumber(factor));
+  },
+  $min: (doc, path, candidate) => {
+    const located = getAtPath(doc, path);
+    if (!located?.exists) {
+      setAtPath(doc, path, candidate);
+      return;
+    }
+    if (shouldReplaceForMin(located.container[located.leaf], candidate)) {
+      setAtPath(doc, path, candidate);
+    }
+  },
+  $max: (doc, path, candidate) => {
+    const located = getAtPath(doc, path);
+    if (!located?.exists) {
+      setAtPath(doc, path, candidate);
+      return;
+    }
+    if (shouldReplaceForMax(located.container[located.leaf], candidate)) {
+      setAtPath(doc, path, candidate);
+    }
+  },
+  $rename: (doc, path, newPath) => {
+    if (typeof newPath !== "string") return;
+    const located = getAtPath(doc, path);
+    if (!located?.exists) return;
+    const value = located.container[located.leaf];
+    unsetAtPath(doc, path);
+    setAtPath(doc, newPath, value);
+  },
+  $currentDate: (doc, path, spec) => {
+    const wantTimestamp = typeof spec === "object" && spec !== null && spec.$type === "timestamp";
+    setAtPath(doc, path, wantTimestamp ? Date.now() : /* @__PURE__ */ new Date());
+  },
+  $push: (doc, path, pushSpec) => {
+    const located = getAtPath(doc, path);
+    const existing = located?.exists ? toArray(located.container[located.leaf]) ?? [] : [];
+    const next = [...existing];
+    if (typeof pushSpec === "object" && pushSpec !== null && "$each" in pushSpec && Array.isArray(pushSpec.$each)) {
+      next.push(...pushSpec.$each);
+    } else {
+      next.push(pushSpec);
+    }
+    setAtPath(doc, path, next);
+  },
+  $addToSet: (doc, path, item) => {
+    const located = getAtPath(doc, path);
+    const existing = located?.exists ? toArray(located.container[located.leaf]) ?? [] : [];
+    const next = [...existing];
+    const rawItems = typeof item === "object" && item !== null && "$each" in item ? item.$each : item;
+    const toAdd = Array.isArray(rawItems) ? rawItems : [rawItems];
+    for (const candidate of toAdd) {
+      if (!next.some((existingEntry) => deepEqualJson(existingEntry, candidate))) {
+        next.push(candidate);
+      }
+    }
+    setAtPath(doc, path, next);
+  },
+  $pull: (doc, path, matcher) => {
+    const located = getAtPath(doc, path);
+    const existing = located?.exists ? toArray(located.container[located.leaf]) : void 0;
+    if (!existing) return;
+    const filtered = existing.filter((entry) => !deepEqualJson(entry, matcher));
+    setAtPath(doc, path, filtered);
+  },
+  $pullAll: (doc, path, values) => {
+    const located = getAtPath(doc, path);
+    const existing = located?.exists ? toArray(located.container[located.leaf]) : void 0;
+    if (!existing || !Array.isArray(values)) return;
+    const filtered = existing.filter((entry) => !values.some((target) => deepEqualJson(entry, target)));
+    setAtPath(doc, path, filtered);
+  },
+  $pop: (doc, path, direction) => {
+    const located = getAtPath(doc, path);
+    const existing = located?.exists ? toArray(located.container[located.leaf]) : void 0;
+    if (!existing || existing.length === 0) return;
+    const next = direction === -1 ? existing.slice(1) : existing.slice(0, -1);
+    setAtPath(doc, path, next);
+  }
+};
+const applyOperator = (doc, operator, fields) => {
+  const fn = operators[operator];
+  if (!fn || fields === null || typeof fields !== "object") return;
+  for (const [path, argument] of Object.entries(fields)) {
+    fn(doc, path, argument);
+  }
+};
+const applyUpdate = (doc, update) => {
+  const result = { ...doc };
+  for (const [key, value] of Object.entries(update)) {
+    if (key.startsWith("$")) {
+      applyOperator(result, key, value);
+    } else {
+      setAtPath(result, key, value);
+    }
+  }
+  return result;
+};
+
 const updateMethods = ["update", "updateOne", "replaceOne", "updateMany", "findOneAndUpdate", "findOneAndReplace", "findByIdAndUpdate"];
 const trackChangedFields = (fields, updated, changed) => {
   if (!fields) return;
@@ -477,30 +743,14 @@ const trackChangedFields = (fields, updated, changed) => {
     changed.set(root, updated[root]);
   }
 };
-const applyPullAll = (updated, fields, changed) => {
-  for (const [field, values] of Object.entries(fields)) {
-    const arr = updated[field];
-    if (Array.isArray(arr)) {
-      const filtered = arr.filter((item) => !values.some((v) => JSON.stringify(v) === JSON.stringify(item)));
-      updated[field] = filtered;
-      changed.set(field, filtered);
-    }
-  }
-};
 const assignUpdate = (document, update, commands) => {
-  let updated = powerAssign.assign(document.toObject(toObjectOptions), update);
+  let updated = applyUpdate(document.toObject(toObjectOptions), update);
   const changedByCommand = /* @__PURE__ */ new Map();
   for (const command of commands) {
     const [op = ""] = Object.keys(command);
     const fields = command[op];
-    try {
-      updated = powerAssign.assign(updated, command);
-      trackChangedFields(fields, updated, changedByCommand);
-    } catch {
-      if (op === "$pullAll" && fields) {
-        applyPullAll(updated, fields, changedByCommand);
-      }
-    }
+    updated = applyUpdate(updated, command);
+    trackChangedFields(fields, updated, changedByCommand);
   }
   const doc = document.set(updated).toObject(toObjectOptions);
   for (const [field, value] of changedByCommand) {
@@ -555,7 +805,9 @@ const updateHooksInitialize = (schema, opts) => {
     const updateQuery = this.getUpdate();
     const { update, commands } = splitUpdateAndCommands(updateQuery);
     const filter = this.getFilter();
-    const candidates = [update, assignUpdate(model.hydrate({}), update, commands), filter];
+    const simulated = assignUpdate(model.hydrate({}), update, commands);
+    const simulatedFilter = Object.fromEntries(Object.entries(simulated).filter(([, v]) => v !== void 0));
+    const candidates = [update, simulatedFilter, filter];
     let current = null;
     for (const query of candidates) {
       if (current || isEmpty(query)) continue;

package/dist/index.d.cts

@@ -1,7 +1,27 @@
 import { Types, Query, HydratedDocument, Schema } from 'mongoose';
-import { Operation } from 'fast-json-patch';
 import EventEmitter from 'node:events';
 
+interface AddOperation<T> {
+    op: 'add';
+    path: string;
+    value: T;
+}
+interface RemoveOperation {
+    op: 'remove';
+    path: string;
+}
+interface ReplaceOperation<T> {
+    op: 'replace';
+    path: string;
+    value: T;
+}
+interface TestOperation<T> {
+    op: 'test';
+    path: string;
+    value: T;
+}
+type Operation = AddOperation<unknown> | RemoveOperation | ReplaceOperation<unknown> | TestOperation<unknown>;
+
 interface History {
     op: string;
     modelName: string;

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sources":["../src/types.ts","../src/em.ts","../src/ms.ts","../src/helpers.ts","../src/index.ts"],"mappings":";;;;AAGM,UAAW,OAAO;;;;kBAIR,KAAK,CAAC,QAAQ;;;;;;YAMpB,SAAS;gBACL,IAAI;gBACJ,IAAI;;AAGZ,UAAW,UAAU;aAChB,gBAAgB;UACnB,gBAAgB;YACd,SAAS;;AAGb,UAAW,YAAY;;;;;kBAKb,gBAAgB;kBAChB,gBAAgB;;;;AAK1B,KAAM,WAAW,MAAM,KAAK;;cAAiC,YAAY;;AAEzE,KAAM,IAAI,GAAG,MAAM;AAEnB,KAAM,QAAQ,GAAG,MAAM;AAEvB,UAAW,aAAa;;;;;;oBAMZ,gBAAgB,QAAQ,OAAO,CAAC,IAAI,IAAI,IAAI;sBAC1C,gBAAgB,QAAQ,OAAO;wBAC7B,gBAAgB,QAAQ,OAAO,CAAC,QAAQ,IAAI,QAAQ;;;uBAGrD,gBAAgB,UAAU,OAAO;sBAClC,KAAK;;;ACnDzB,cAAM,iBAAkB,SAAQ,YAAY;;AAC5C,cAAM,EAAE,mBAA0B;;ACKlC,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;AC6FpF,cAAa,kBAAkB,QAAe,QAAQ,oBAAoB,KAAK,cAAY,OAAO;;AC1HlG,cAAa,kBAAkB,cAAe,MAAM,WAAW,aAAa","names":[]}
+{"version":3,"file":"index.d.cts","sources":["../src/json-patch.ts","../src/types.ts","../src/em.ts","../src/ms.ts","../src/helpers.ts","../src/index.ts"],"mappings":";;;AAAM,UAAW,YAAY;;;;;AAMvB,UAAW,eAAe;;;;AAK1B,UAAW,gBAAgB;;;;;AAM3B,UAAW,aAAa;;;;;AAMxB,KAAM,SAAS,GAAG,YAAY,YAAY,eAAe,GAAG,gBAAgB,YAAY,aAAa;;ACpBrG,UAAW,OAAO;;;;kBAIR,KAAK,CAAC,QAAQ;;;;;;YAMpB,SAAS;gBACL,IAAI;gBACJ,IAAI;;AAGZ,UAAW,UAAU;aAChB,gBAAgB;UACnB,gBAAgB;YACd,SAAS;;AAGb,UAAW,YAAY;;;;;kBAKb,gBAAgB;kBAChB,gBAAgB;;;;AAK1B,KAAM,WAAW,MAAM,KAAK;;cAAiC,YAAY;;AAEzE,KAAM,IAAI,GAAG,MAAM;AAEnB,KAAM,QAAQ,GAAG,MAAM;AAEvB,UAAW,aAAa;;;;;;oBAMZ,gBAAgB,QAAQ,OAAO,CAAC,IAAI,IAAI,IAAI;sBAC1C,gBAAgB,QAAQ,OAAO;wBAC7B,gBAAgB,QAAQ,OAAO,CAAC,QAAQ,IAAI,QAAQ;;;uBAGrD,gBAAgB,UAAU,OAAO;sBAClC,KAAK;;;ACnDzB,cAAM,iBAAkB,SAAQ,YAAY;;AAC5C,cAAM,EAAE,mBAA0B;;ACKlC,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;AC6FpF,cAAa,kBAAkB,QAAe,QAAQ,oBAAoB,KAAK,cAAY,OAAO;;AC1HlG,cAAa,kBAAkB,cAAe,MAAM,WAAW,aAAa","names":[]}

package/dist/index.d.mts

@@ -1,7 +1,27 @@
 import { Types, Query, HydratedDocument, Schema } from 'mongoose';
-import { Operation } from 'fast-json-patch';
 import EventEmitter from 'node:events';
 
+interface AddOperation<T> {
+    op: 'add';
+    path: string;
+    value: T;
+}
+interface RemoveOperation {
+    op: 'remove';
+    path: string;
+}
+interface ReplaceOperation<T> {
+    op: 'replace';
+    path: string;
+    value: T;
+}
+interface TestOperation<T> {
+    op: 'test';
+    path: string;
+    value: T;
+}
+type Operation = AddOperation<unknown> | RemoveOperation | ReplaceOperation<unknown> | TestOperation<unknown>;
+
 interface History {
     op: string;
     modelName: string;

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sources":["../src/types.ts","../src/em.ts","../src/ms.ts","../src/helpers.ts","../src/index.ts"],"mappings":";;;;AAGM,UAAW,OAAO;;;;kBAIR,KAAK,CAAC,QAAQ;;;;;;YAMpB,SAAS;gBACL,IAAI;gBACJ,IAAI;;AAGZ,UAAW,UAAU;aAChB,gBAAgB;UACnB,gBAAgB;YACd,SAAS;;AAGb,UAAW,YAAY;;;;;kBAKb,gBAAgB;kBAChB,gBAAgB;;;;AAK1B,KAAM,WAAW,MAAM,KAAK;;cAAiC,YAAY;;AAEzE,KAAM,IAAI,GAAG,MAAM;AAEnB,KAAM,QAAQ,GAAG,MAAM;AAEvB,UAAW,aAAa;;;;;;oBAMZ,gBAAgB,QAAQ,OAAO,CAAC,IAAI,IAAI,IAAI;sBAC1C,gBAAgB,QAAQ,OAAO;wBAC7B,gBAAgB,QAAQ,OAAO,CAAC,QAAQ,IAAI,QAAQ;;;uBAGrD,gBAAgB,UAAU,OAAO;sBAClC,KAAK;;;ACnDzB,cAAM,iBAAkB,SAAQ,YAAY;;AAC5C,cAAM,EAAE,mBAA0B;;ACKlC,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;AC6FpF,cAAa,kBAAkB,QAAe,QAAQ,oBAAoB,KAAK,cAAY,OAAO;;AC1HlG,cAAa,kBAAkB,cAAe,MAAM,WAAW,aAAa","names":[]}
+{"version":3,"file":"index.d.mts","sources":["../src/json-patch.ts","../src/types.ts","../src/em.ts","../src/ms.ts","../src/helpers.ts","../src/index.ts"],"mappings":";;;AAAM,UAAW,YAAY;;;;;AAMvB,UAAW,eAAe;;;;AAK1B,UAAW,gBAAgB;;;;;AAM3B,UAAW,aAAa;;;;;AAMxB,KAAM,SAAS,GAAG,YAAY,YAAY,eAAe,GAAG,gBAAgB,YAAY,aAAa;;ACpBrG,UAAW,OAAO;;;;kBAIR,KAAK,CAAC,QAAQ;;;;;;YAMpB,SAAS;gBACL,IAAI;gBACJ,IAAI;;AAGZ,UAAW,UAAU;aAChB,gBAAgB;UACnB,gBAAgB;YACd,SAAS;;AAGb,UAAW,YAAY;;;;;kBAKb,gBAAgB;kBAChB,gBAAgB;;;;AAK1B,KAAM,WAAW,MAAM,KAAK;;cAAiC,YAAY;;AAEzE,KAAM,IAAI,GAAG,MAAM;AAEnB,KAAM,QAAQ,GAAG,MAAM;AAEvB,UAAW,aAAa;;;;;;oBAMZ,gBAAgB,QAAQ,OAAO,CAAC,IAAI,IAAI,IAAI;sBAC1C,gBAAgB,QAAQ,OAAO;wBAC7B,gBAAgB,QAAQ,OAAO,CAAC,QAAQ,IAAI,QAAQ;;;uBAGrD,gBAAgB,UAAU,OAAO;sBAClC,KAAK;;;ACnDzB,cAAM,iBAAkB,SAAQ,YAAY;;AAC5C,cAAM,EAAE,mBAA0B;;ACKlC,cAAa,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCZ,KAAM,IAAI,gBAAgB,KAAK;AAE/B,KAAM,QAAQ,sCAAsC,IAAI,kBAAkB,IAAI;;AC6FpF,cAAa,kBAAkB,QAAe,QAAQ,oBAAoB,KAAK,cAAY,OAAO;;AC1HlG,cAAa,kBAAkB,cAAe,MAAM,WAAW,aAAa","names":[]}