@rimbu/deep 0.14.5 → 1.0.0-alpha.1

package/dist/cjs/selector.js

@@ -0,0 +1,581 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/selector.mts
+var selector_exports = {};
+__export(selector_exports, {
+  select: () => select
+});
+module.exports = __toCommonJS(selector_exports);
+
+// src/path.mts
+var Path;
+((Path3) => {
+  Path3.stringSplitRegex = /\?\.|\.|\[|\]/g;
+  function stringSplit(path) {
+    return path.split(Path3.stringSplitRegex);
+  }
+  Path3.stringSplit = stringSplit;
+})(Path || (Path = {}));
+function getAt(source, path) {
+  if (path === "") {
+    return source;
+  }
+  const items = Path.stringSplit(path);
+  let result = source;
+  for (const item of items) {
+    if (void 0 === item || item === "" || item === "[") {
+      continue;
+    }
+    if (void 0 === result || null === result) {
+      return void 0;
+    }
+    result = result[item];
+  }
+  return result;
+}
+function patchAt(source, path, patchItem) {
+  if (path === "") {
+    return deep_exports.patch(source, patchItem);
+  }
+  const items = Path.stringSplit(path);
+  function createPatchPart(index, target) {
+    if (index === items.length) {
+      return patchItem;
+    }
+    const item = items[index];
+    if (void 0 === item || item === "") {
+      return createPatchPart(index + 1, target);
+    }
+    if (item === "[") {
+      return createPatchPart(index + 1, target);
+    }
+    const result = {
+      [item]: createPatchPart(index + 1, target[item])
+    };
+    if (Array.isArray(target)) {
+      return result;
+    }
+    return [result];
+  }
+  return deep_exports.patch(source, createPatchPart(0, source));
+}
+
+// src/match.mts
+var import_base = require("@rimbu/base");
+function match(source, matcher, failureLog) {
+  return matchEntry(source, source, source, matcher, failureLog);
+}
+function matchEntry(source, parent, root, matcher, failureLog) {
+  if (Object.is(source, matcher)) {
+    return true;
+  }
+  if (matcher === null || matcher === void 0) {
+    failureLog?.push(
+      `value ${JSON.stringify(source)} did not match matcher ${matcher}`
+    );
+    return false;
+  }
+  if (typeof source === "function") {
+    const result = Object.is(source, matcher);
+    if (!result) {
+      failureLog?.push(
+        `both value and matcher are functions, but they do not have the same reference`
+      );
+    }
+    return result;
+  }
+  if (typeof matcher === "function") {
+    const matcherResult = matcher(source, parent, root);
+    if (typeof matcherResult === "boolean") {
+      if (!matcherResult) {
+        failureLog?.push(
+          `function matcher returned false for value ${JSON.stringify(source)}`
+        );
+      }
+      return matcherResult;
+    }
+    return matchEntry(source, parent, root, matcherResult, failureLog);
+  }
+  if ((0, import_base.isPlainObj)(source)) {
+    return matchPlainObj(source, parent, root, matcher, failureLog);
+  }
+  if (Array.isArray(source)) {
+    return matchArr(source, parent, root, matcher, failureLog);
+  }
+  failureLog?.push(
+    `value ${JSON.stringify(
+      source
+    )} does not match given matcher ${JSON.stringify(matcher)}`
+  );
+  return false;
+}
+function matchArr(source, parent, root, matcher, failureLog) {
+  if (Array.isArray(matcher)) {
+    const length = source.length;
+    if (length !== matcher.length) {
+      failureLog?.push(
+        `array lengths are not equal: value length ${source.length} !== matcher length ${matcher.length}`
+      );
+      return false;
+    }
+    let index = -1;
+    while (++index < length) {
+      if (!matchEntry(source[index], source, root, matcher[index], failureLog)) {
+        failureLog?.push(
+          `index ${index} does not match with value ${JSON.stringify(
+            source[index]
+          )} and matcher ${matcher[index]}`
+        );
+        return false;
+      }
+    }
+    return true;
+  }
+  if (typeof matcher === "object" && null !== matcher) {
+    if (`every` in matcher) {
+      return matchCompound(
+        source,
+        parent,
+        root,
+        ["every", ...matcher.every],
+        failureLog
+      );
+    }
+    if (`some` in matcher) {
+      return matchCompound(
+        source,
+        parent,
+        root,
+        ["some", ...matcher.some],
+        failureLog
+      );
+    }
+    if (`none` in matcher) {
+      return matchCompound(
+        source,
+        parent,
+        root,
+        ["none", ...matcher.none],
+        failureLog
+      );
+    }
+    if (`single` in matcher) {
+      return matchCompound(
+        source,
+        parent,
+        root,
+        ["single", ...matcher.single],
+        failureLog
+      );
+    }
+    if (`someItem` in matcher) {
+      return matchTraversal(
+        source,
+        root,
+        "someItem",
+        matcher.someItem,
+        failureLog
+      );
+    }
+    if (`everyItem` in matcher) {
+      return matchTraversal(
+        source,
+        root,
+        "everyItem",
+        matcher.everyItem,
+        failureLog
+      );
+    }
+    if (`noneItem` in matcher) {
+      return matchTraversal(
+        source,
+        root,
+        "noneItem",
+        matcher.noneItem,
+        failureLog
+      );
+    }
+    if (`singleItem` in matcher) {
+      return matchTraversal(
+        source,
+        root,
+        "singleItem",
+        matcher.singleItem,
+        failureLog
+      );
+    }
+  }
+  for (const index in matcher) {
+    const matcherAtIndex = matcher[index];
+    if (!(index in source)) {
+      failureLog?.push(
+        `index ${index} does not exist in source ${JSON.stringify(
+          source
+        )} but should match matcher ${JSON.stringify(matcherAtIndex)}`
+      );
+      return false;
+    }
+    const result = matchEntry(
+      source[index],
+      source,
+      root,
+      matcherAtIndex,
+      failureLog
+    );
+    if (!result) {
+      failureLog?.push(
+        `index ${index} does not match with value ${JSON.stringify(
+          source[index]
+        )} and matcher ${JSON.stringify(matcherAtIndex)}`
+      );
+      return false;
+    }
+  }
+  return true;
+}
+function matchPlainObj(source, parent, root, matcher, failureLog) {
+  if (Array.isArray(matcher)) {
+    return matchCompound(source, parent, root, matcher, failureLog);
+  }
+  for (const key in matcher) {
+    if (!(key in source)) {
+      failureLog?.push(
+        `key ${key} is specified in matcher but not present in value ${JSON.stringify(
+          source
+        )}`
+      );
+      return false;
+    }
+    const result = matchEntry(
+      source[key],
+      source,
+      root,
+      matcher[key],
+      failureLog
+    );
+    if (!result) {
+      failureLog?.push(
+        `key ${key} does not match in value ${JSON.stringify(
+          source[key]
+        )} with matcher ${JSON.stringify(matcher[key])}`
+      );
+      return false;
+    }
+  }
+  return true;
+}
+function matchCompound(source, parent, root, compound, failureLog) {
+  const matchType = compound[0];
+  const length = compound.length;
+  let index = 0;
+  switch (matchType) {
+    case "every": {
+      while (++index < length) {
+        const result = matchEntry(
+          source,
+          parent,
+          root,
+          compound[index],
+          failureLog
+        );
+        if (!result) {
+          failureLog?.push(
+            `in compound "every": match at index ${index} failed`
+          );
+          return false;
+        }
+      }
+      return true;
+    }
+    case "none": {
+      while (++index < length) {
+        const result = matchEntry(
+          source,
+          parent,
+          root,
+          compound[index],
+          failureLog
+        );
+        if (result) {
+          failureLog?.push(
+            `in compound "none": match at index ${index} succeeded`
+          );
+          return false;
+        }
+      }
+      return true;
+    }
+    case "single": {
+      let onePassed = false;
+      while (++index < length) {
+        const result = matchEntry(
+          source,
+          parent,
+          root,
+          compound[index],
+          failureLog
+        );
+        if (result) {
+          if (onePassed) {
+            failureLog?.push(
+              `in compound "single": multiple matches succeeded`
+            );
+            return false;
+          }
+          onePassed = true;
+        }
+      }
+      if (!onePassed) {
+        failureLog?.push(`in compound "single": no matches succeeded`);
+      }
+      return onePassed;
+    }
+    case "some": {
+      while (++index < length) {
+        const result = matchEntry(
+          source,
+          parent,
+          root,
+          compound[index],
+          failureLog
+        );
+        if (result) {
+          return true;
+        }
+      }
+      failureLog?.push(`in compound "some": no matches succeeded`);
+      return false;
+    }
+  }
+}
+function matchTraversal(source, root, matchType, matcher, failureLog) {
+  let index = -1;
+  const length = source.length;
+  switch (matchType) {
+    case "someItem": {
+      while (++index < length) {
+        if (matchEntry(source[index], source, root, matcher, failureLog)) {
+          return true;
+        }
+      }
+      failureLog?.push(
+        `in array traversal "someItem": no items matched given matcher`
+      );
+      return false;
+    }
+    case "everyItem": {
+      while (++index < length) {
+        if (!matchEntry(source[index], source, root, matcher, failureLog)) {
+          failureLog?.push(
+            `in array traversal "everyItem": at least one item did not match given matcher`
+          );
+          return false;
+        }
+      }
+      return true;
+    }
+    case "noneItem": {
+      while (++index < length) {
+        if (matchEntry(source[index], source, root, matcher, failureLog)) {
+          failureLog?.push(
+            `in array traversal "noneItem": at least one item matched given matcher`
+          );
+          return false;
+        }
+      }
+      return true;
+    }
+    case "singleItem": {
+      let singleMatched = false;
+      while (++index < length) {
+        if (matchEntry(source[index], source, root, matcher, failureLog)) {
+          if (singleMatched) {
+            failureLog?.push(
+              `in array traversal "singleItem": more than one item matched given matcher`
+            );
+            return false;
+          }
+          singleMatched = true;
+        }
+      }
+      if (!singleMatched) {
+        failureLog?.push(
+          `in array traversal "singleItem": no item matched given matcher`
+        );
+        return false;
+      }
+      return true;
+    }
+  }
+}
+
+// src/deep.mts
+var deep_exports = {};
+__export(deep_exports, {
+  getAt: () => getAt,
+  getAtWith: () => getAtWith,
+  match: () => match,
+  matchAt: () => matchAt,
+  matchAtWith: () => matchAtWith,
+  matchWith: () => matchWith,
+  patch: () => patch,
+  patchAt: () => patchAt,
+  patchAtWith: () => patchAtWith,
+  patchWith: () => patchWith,
+  protect: () => protect,
+  select: () => select,
+  selectAt: () => selectAt,
+  selectAtWith: () => selectAtWith,
+  selectWith: () => selectWith,
+  withType: () => withType
+});
+
+// src/patch.mts
+var import_base2 = require("@rimbu/base");
+function patch(value, patchItem) {
+  return patchEntry(value, value, value, patchItem);
+}
+function patchEntry(value, parent, root, patchItem) {
+  if (Object.is(value, patchItem)) {
+    return value;
+  }
+  if (typeof value === "function") {
+    return patchItem;
+  }
+  if (typeof patchItem === "function") {
+    const item = patchItem(value, parent, root);
+    return patchEntry(value, parent, root, item);
+  }
+  if ((0, import_base2.isPlainObj)(value)) {
+    return patchPlainObj(value, root, patchItem);
+  }
+  if (Array.isArray(value)) {
+    return patchArr(value, root, patchItem);
+  }
+  return patchItem;
+}
+function patchPlainObj(value, root, patchItem) {
+  if (!Array.isArray(patchItem)) {
+    return patchItem;
+  }
+  const result = { ...value };
+  let anyChange = false;
+  for (const entry of patchItem) {
+    const currentRoot = value === root ? { ...result } : root;
+    const parent = { ...result };
+    for (const key in entry) {
+      const currentValue = result[key];
+      const newValue = patchEntry(
+        currentValue,
+        parent,
+        currentRoot,
+        entry[key]
+      );
+      if (!Object.is(currentValue, newValue)) {
+        anyChange = true;
+        result[key] = newValue;
+      }
+    }
+  }
+  if (anyChange) {
+    return result;
+  }
+  return value;
+}
+function patchArr(value, root, patchItem) {
+  if (Array.isArray(patchItem)) {
+    return patchItem;
+  }
+  const result = [...value];
+  let anyChange = false;
+  for (const index in patchItem) {
+    const numIndex = index;
+    const currentValue = result[numIndex];
+    const newValue = patchEntry(
+      currentValue,
+      value,
+      root,
+      patchItem[index]
+    );
+    if (!Object.is(newValue, currentValue)) {
+      anyChange = true;
+      result[numIndex] = newValue;
+    }
+  }
+  if (anyChange) {
+    return result;
+  }
+  return value;
+}
+
+// src/deep.mts
+function protect(source) {
+  return source;
+}
+function getAtWith(path) {
+  return (source) => deep_exports.getAt(source, path);
+}
+function patchWith(patchItem) {
+  return (source) => deep_exports.patch(source, patchItem);
+}
+function patchAtWith(path, patchItem) {
+  return (source) => deep_exports.patchAt(source, path, patchItem);
+}
+function matchWith(matcher) {
+  return (source) => deep_exports.match(source, matcher);
+}
+function matchAt(source, path, matcher) {
+  return deep_exports.match(deep_exports.getAt(source, path), matcher);
+}
+function matchAtWith(path, matcher) {
+  return (source) => deep_exports.matchAt(source, path, matcher);
+}
+function selectWith(selector) {
+  return (source) => deep_exports.select(source, selector);
+}
+function selectAt(source, path, selector) {
+  return deep_exports.select(deep_exports.getAt(source, path), selector);
+}
+function selectAtWith(path, selector) {
+  return (source) => deep_exports.selectAt(source, path, selector);
+}
+function withType() {
+  return deep_exports;
+}
+
+// src/selector.mts
+function select(source, selector) {
+  if (typeof selector === "function") {
+    return selector(source);
+  } else if (typeof selector === "string") {
+    return deep_exports.getAt(source, selector);
+  } else if (Array.isArray(selector)) {
+    return selector.map((s) => select(source, s));
+  }
+  const result = {};
+  for (const key in selector) {
+    result[key] = select(source, selector[key]);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  select
+});

package/dist/cjs/tuple.js

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tuple.mts
+var tuple_exports = {};
+__export(tuple_exports, {
+  Tuple: () => Tuple
+});
+module.exports = __toCommonJS(tuple_exports);
+var import_base = require("@rimbu/base");
+var Tuple;
+((Tuple2) => {
+  function of(...values) {
+    return values;
+  }
+  Tuple2.of = of;
+  function getIndex(tuple, index) {
+    return tuple[index];
+  }
+  Tuple2.getIndex = getIndex;
+  function first(tuple) {
+    return tuple[0];
+  }
+  Tuple2.first = first;
+  function second(tuple) {
+    return tuple[1];
+  }
+  Tuple2.second = second;
+  function last(tuple) {
+    return tuple[tuple.length - 1];
+  }
+  Tuple2.last = last;
+  function updateAt(tuple, index, updater) {
+    return import_base.Arr.update(tuple, index, updater);
+  }
+  Tuple2.updateAt = updateAt;
+  function append(tuple, ...values) {
+    return [...tuple, ...values];
+  }
+  Tuple2.append = append;
+  function concat(tuple1, tuple2) {
+    return tuple1.concat(tuple2);
+  }
+  Tuple2.concat = concat;
+  function init(tuple) {
+    return import_base.Arr.init(tuple);
+  }
+  Tuple2.init = init;
+  function tail(tuple) {
+    return import_base.Arr.tail(tuple);
+  }
+  Tuple2.tail = tail;
+})(Tuple || (Tuple = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Tuple
+});

package/dist/{module/deep.js → esm/deep.mjs}

@@ -1,8 +1,8 @@
-import { Deep } from './internal';
-export { match } from './match';
-export { patch } from './patch';
-export { getAt, patchAt } from './path';
-export { select } from './selector';
+import { Deep } from './internal.mjs';
+export { match } from './match.mjs';
+export { patch } from './patch.mjs';
+export { getAt, patchAt } from './path.mjs';
+export { select } from './selector.mjs';
 /**
  * Returns the same value wrapped in the `Protected` type.
  * @typeparam T - the source value type
@@ -189,4 +189,4 @@ export function selectAtWith(path, selector) {
 export function withType() {
     return Deep;
 }
-//# sourceMappingURL=deep.js.map
+//# sourceMappingURL=deep.mjs.map

package/dist/esm/deep.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep.mjs","sourceRoot":"","sources":["../../src/deep.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAEtC,OAAO,EAAE,KAAK,EAAc,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,KAAK,EAAc,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAa,MAAM,YAAY,CAAC;AAEvD,OAAO,EAAE,MAAM,EAAiB,MAAM,gBAAgB,CAAC;AAEvD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,OAAO,CAAI,MAAS;IAClC,OAAO,MAAsB,CAAC;AAChC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,SAAS,CACvB,IAAO;IAEP,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,SAAS,CACvB,SAAwB;IAExB,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,SAAgB,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,WAAW,CACzB,IAAO,EACP,SAAwD;IAExD,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,SAAgB,CAAC,CAAC;AAClE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,SAAS,CAAI,OAAiB;IAC5C,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,OAAO,CACrB,MAAS,EACT,IAAO,EACP,OAAiC;IAEjC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,WAAW,CACzB,IAAO,EACP,OAAsC;IAEtC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,OAAc,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,UAAU,CACxB,QAA4B;IAE5B,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AACnD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,QAAQ,CAKtB,MAAS,EACT,IAAO,EACP,QAA4B;IAE5B,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,YAAY,CAK1B,IAAO,EACP,QAA4B;IAE5B,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;AAC3D,CAAC;AAkID;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,QAAQ;IACtB,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/{module/index.js → esm/index.mjs}

@@ -5,14 +5,14 @@
  * <br/>
  * See the [Rimbu docs Deep overview page](/docs/deep/overview) for more information.
  */
-export { Tuple } from './tuple';
-export { Path } from './internal';
-export * from './deep';
-import * as Deep from './deep';
+export { Tuple } from './tuple.mjs';
+export { Path } from './internal.mjs';
+export * from './deep.mjs';
+import * as Deep from './deep.mjs';
 export { 
 /**
  * Convenience namespace offering access to most common functions used in the `@rimbu/deep` package.
  * These are mainly utilities to patch and match plain JavaScript objects.
  */
 Deep, };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/index.mts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGpC,OAAO,EAAE,IAAI,EAA6B,MAAM,gBAAgB,CAAC;AAEjE,cAAc,YAAY,CAAC;AAE3B,OAAO,KAAK,IAAI,MAAM,YAAY,CAAC;AACnC,OAAO;AACL;;;GAGG;AACH,IAAI,GACL,CAAC"}

package/dist/esm/internal.mjs

@@ -0,0 +1,5 @@
+export { Path } from './path.mjs';
+export {} from './match.mjs';
+import * as Deep from './deep.mjs';
+export { Deep };
+//# sourceMappingURL=internal.mjs.map

package/dist/esm/internal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.mjs","sourceRoot":"","sources":["../../src/internal.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,EAAc,MAAM,aAAa,CAAC;AAIzC,OAAO,KAAK,IAAI,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,IAAI,EAAE,CAAC"}