@lls/store 24.10.0 → 24.11.0-076370c6

package/lib/index.js

@@ -0,0 +1,1817 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// <define:import.meta>
+var init_define_import_meta = __esm({
+  "<define:import.meta>"() {
+  }
+});
+
+// ../../node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/lib/defaultMemoize.js
+var require_defaultMemoize = __commonJS({
+  "../../node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/lib/defaultMemoize.js"(exports) {
+    "use strict";
+    init_define_import_meta();
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.createCacheKeyComparator = createCacheKeyComparator;
+    exports.defaultEqualityCheck = void 0;
+    exports.defaultMemoize = defaultMemoize;
+    var NOT_FOUND = "NOT_FOUND";
+    function createSingletonCache(equals) {
+      var entry;
+      return {
+        get: function get(key) {
+          if (entry && equals(entry.key, key)) {
+            return entry.value;
+          }
+          return NOT_FOUND;
+        },
+        put: function put(key, value) {
+          entry = {
+            key,
+            value
+          };
+        },
+        getEntries: function getEntries() {
+          return entry ? [entry] : [];
+        },
+        clear: function clear() {
+          entry = void 0;
+        }
+      };
+    }
+    function createLruCache(maxSize, equals) {
+      var entries = [];
+      function get(key) {
+        var cacheIndex = entries.findIndex(function(entry2) {
+          return equals(key, entry2.key);
+        });
+        if (cacheIndex > -1) {
+          var entry = entries[cacheIndex];
+          if (cacheIndex > 0) {
+            entries.splice(cacheIndex, 1);
+            entries.unshift(entry);
+          }
+          return entry.value;
+        }
+        return NOT_FOUND;
+      }
+      function put(key, value) {
+        if (get(key) === NOT_FOUND) {
+          entries.unshift({
+            key,
+            value
+          });
+          if (entries.length > maxSize) {
+            entries.pop();
+          }
+        }
+      }
+      function getEntries() {
+        return entries;
+      }
+      function clear() {
+        entries = [];
+      }
+      return {
+        get,
+        put,
+        getEntries,
+        clear
+      };
+    }
+    var defaultEqualityCheck = function defaultEqualityCheck2(a, b) {
+      return a === b;
+    };
+    exports.defaultEqualityCheck = defaultEqualityCheck;
+    function createCacheKeyComparator(equalityCheck) {
+      return function areArgumentsShallowlyEqual(prev, next) {
+        if (prev === null || next === null || prev.length !== next.length) {
+          return false;
+        }
+        var length = prev.length;
+        for (var i = 0; i < length; i++) {
+          if (!equalityCheck(prev[i], next[i])) {
+            return false;
+          }
+        }
+        return true;
+      };
+    }
+    function defaultMemoize(func, equalityCheckOrOptions) {
+      var providedOptions = typeof equalityCheckOrOptions === "object" ? equalityCheckOrOptions : {
+        equalityCheck: equalityCheckOrOptions
+      };
+      var _providedOptions$equa = providedOptions.equalityCheck, equalityCheck = _providedOptions$equa === void 0 ? defaultEqualityCheck : _providedOptions$equa, _providedOptions$maxS = providedOptions.maxSize, maxSize = _providedOptions$maxS === void 0 ? 1 : _providedOptions$maxS, resultEqualityCheck = providedOptions.resultEqualityCheck;
+      var comparator = createCacheKeyComparator(equalityCheck);
+      var cache = maxSize === 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator);
+      function memoized() {
+        var value = cache.get(arguments);
+        if (value === NOT_FOUND) {
+          value = func.apply(null, arguments);
+          if (resultEqualityCheck) {
+            var entries = cache.getEntries();
+            var matchingEntry = entries.find(function(entry) {
+              return resultEqualityCheck(entry.value, value);
+            });
+            if (matchingEntry) {
+              value = matchingEntry.value;
+            }
+          }
+          cache.put(arguments, value);
+        }
+        return value;
+      }
+      memoized.clearCache = function() {
+        return cache.clear();
+      };
+      return memoized;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/lib/index.js"(exports) {
+    "use strict";
+    init_define_import_meta();
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.createSelector = void 0;
+    exports.createSelectorCreator = createSelectorCreator;
+    exports.createStructuredSelector = void 0;
+    Object.defineProperty(exports, "defaultEqualityCheck", {
+      enumerable: true,
+      get: function get() {
+        return _defaultMemoize.defaultEqualityCheck;
+      }
+    });
+    Object.defineProperty(exports, "defaultMemoize", {
+      enumerable: true,
+      get: function get() {
+        return _defaultMemoize.defaultMemoize;
+      }
+    });
+    var _defaultMemoize = require_defaultMemoize();
+    function getDependencies(funcs) {
+      var dependencies = Array.isArray(funcs[0]) ? funcs[0] : funcs;
+      if (!dependencies.every(function(dep) {
+        return typeof dep === "function";
+      })) {
+        var dependencyTypes = dependencies.map(function(dep) {
+          return typeof dep === "function" ? "function " + (dep.name || "unnamed") + "()" : typeof dep;
+        }).join(", ");
+        throw new Error("createSelector expects all input-selectors to be functions, but received the following types: [" + dependencyTypes + "]");
+      }
+      return dependencies;
+    }
+    function createSelectorCreator(memoize) {
+      for (var _len = arguments.length, memoizeOptionsFromArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        memoizeOptionsFromArgs[_key - 1] = arguments[_key];
+      }
+      var createSelector6 = function createSelector7() {
+        for (var _len2 = arguments.length, funcs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          funcs[_key2] = arguments[_key2];
+        }
+        var _recomputations = 0;
+        var _lastResult;
+        var directlyPassedOptions = {
+          memoizeOptions: void 0
+        };
+        var resultFunc = funcs.pop();
+        if (typeof resultFunc === "object") {
+          directlyPassedOptions = resultFunc;
+          resultFunc = funcs.pop();
+        }
+        if (typeof resultFunc !== "function") {
+          throw new Error("createSelector expects an output function after the inputs, but received: [" + typeof resultFunc + "]");
+        }
+        var _directlyPassedOption = directlyPassedOptions, _directlyPassedOption2 = _directlyPassedOption.memoizeOptions, memoizeOptions = _directlyPassedOption2 === void 0 ? memoizeOptionsFromArgs : _directlyPassedOption2;
+        var finalMemoizeOptions = Array.isArray(memoizeOptions) ? memoizeOptions : [memoizeOptions];
+        var dependencies = getDependencies(funcs);
+        var memoizedResultFunc = memoize.apply(void 0, [function recomputationWrapper() {
+          _recomputations++;
+          return resultFunc.apply(null, arguments);
+        }].concat(finalMemoizeOptions));
+        var selector = memoize(function dependenciesChecker() {
+          var params = [];
+          var length = dependencies.length;
+          for (var i = 0; i < length; i++) {
+            params.push(dependencies[i].apply(null, arguments));
+          }
+          _lastResult = memoizedResultFunc.apply(null, params);
+          return _lastResult;
+        });
+        Object.assign(selector, {
+          resultFunc,
+          memoizedResultFunc,
+          dependencies,
+          lastResult: function lastResult() {
+            return _lastResult;
+          },
+          recomputations: function recomputations() {
+            return _recomputations;
+          },
+          resetRecomputations: function resetRecomputations() {
+            return _recomputations = 0;
+          }
+        });
+        return selector;
+      };
+      return createSelector6;
+    }
+    var createSelector5 = /* @__PURE__ */ createSelectorCreator(_defaultMemoize.defaultMemoize);
+    exports.createSelector = createSelector5;
+    var createStructuredSelector = function createStructuredSelector2(selectors, selectorCreator) {
+      if (selectorCreator === void 0) {
+        selectorCreator = createSelector5;
+      }
+      if (typeof selectors !== "object") {
+        throw new Error("createStructuredSelector expects first argument to be an object " + ("where each property is a selector, instead received a " + typeof selectors));
+      }
+      var objectKeys = Object.keys(selectors);
+      var resultSelector = selectorCreator(
+        // @ts-ignore
+        objectKeys.map(function(key) {
+          return selectors[key];
+        }),
+        function() {
+          for (var _len3 = arguments.length, values = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+            values[_key3] = arguments[_key3];
+          }
+          return values.reduce(function(composition, value, index) {
+            composition[objectKeys[index]] = value;
+            return composition;
+          }, {});
+        }
+      );
+      return resultSelector;
+    };
+    exports.createStructuredSelector = createStructuredSelector;
+  }
+});
+
+// ../../node_modules/.pnpm/normalizr@3.6.2/node_modules/normalizr/dist/normalizr.js
+var require_normalizr = __commonJS({
+  "../../node_modules/.pnpm/normalizr@3.6.2/node_modules/normalizr/dist/normalizr.js"(exports) {
+    "use strict";
+    init_define_import_meta();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      return Constructor;
+    }
+    function _extends() {
+      _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    function _inheritsLoose(subClass, superClass) {
+      subClass.prototype = Object.create(superClass.prototype);
+      subClass.prototype.constructor = subClass;
+      subClass.__proto__ = superClass;
+    }
+    function isImmutable(object) {
+      return !!(object && typeof object.hasOwnProperty === "function" && (object.hasOwnProperty("__ownerID") || // Immutable.Map
+      object._map && object._map.hasOwnProperty("__ownerID")));
+    }
+    function denormalizeImmutable(schema3, input, unvisit) {
+      return Object.keys(schema3).reduce(function(object, key) {
+        var stringKey = "" + key;
+        if (object.has(stringKey)) {
+          return object.set(stringKey, unvisit(object.get(stringKey), schema3[stringKey]));
+        } else {
+          return object;
+        }
+      }, input);
+    }
+    var getDefaultGetId = function getDefaultGetId2(idAttribute) {
+      return function(input) {
+        return isImmutable(input) ? input.get(idAttribute) : input[idAttribute];
+      };
+    };
+    var EntitySchema = /* @__PURE__ */ function() {
+      function EntitySchema2(key, definition, options) {
+        if (definition === void 0) {
+          definition = {};
+        }
+        if (options === void 0) {
+          options = {};
+        }
+        if (!key || typeof key !== "string") {
+          throw new Error("Expected a string key for Entity, but found " + key + ".");
+        }
+        var _options = options, _options$idAttribute = _options.idAttribute, idAttribute = _options$idAttribute === void 0 ? "id" : _options$idAttribute, _options$mergeStrateg = _options.mergeStrategy, mergeStrategy = _options$mergeStrateg === void 0 ? function(entityA, entityB) {
+          return _extends({}, entityA, entityB);
+        } : _options$mergeStrateg, _options$processStrat = _options.processStrategy, processStrategy = _options$processStrat === void 0 ? function(input) {
+          return _extends({}, input);
+        } : _options$processStrat, _options$fallbackStra = _options.fallbackStrategy, fallbackStrategy = _options$fallbackStra === void 0 ? function(key2, schema3) {
+          return void 0;
+        } : _options$fallbackStra;
+        this._key = key;
+        this._getId = typeof idAttribute === "function" ? idAttribute : getDefaultGetId(idAttribute);
+        this._idAttribute = idAttribute;
+        this._mergeStrategy = mergeStrategy;
+        this._processStrategy = processStrategy;
+        this._fallbackStrategy = fallbackStrategy;
+        this.define(definition);
+      }
+      var _proto = EntitySchema2.prototype;
+      _proto.define = function define2(definition) {
+        this.schema = Object.keys(definition).reduce(function(entitySchema, key) {
+          var _extends2;
+          var schema3 = definition[key];
+          return _extends({}, entitySchema, (_extends2 = {}, _extends2[key] = schema3, _extends2));
+        }, this.schema || {});
+      };
+      _proto.getId = function getId(input, parent, key) {
+        return this._getId(input, parent, key);
+      };
+      _proto.merge = function merge(entityA, entityB) {
+        return this._mergeStrategy(entityA, entityB);
+      };
+      _proto.fallback = function fallback(id, schema3) {
+        return this._fallbackStrategy(id, schema3);
+      };
+      _proto.normalize = function normalize3(input, parent, key, visit2, addEntity, visitedEntities) {
+        var _this = this;
+        var id = this.getId(input, parent, key);
+        var entityType = this.key;
+        if (!(entityType in visitedEntities)) {
+          visitedEntities[entityType] = {};
+        }
+        if (!(id in visitedEntities[entityType])) {
+          visitedEntities[entityType][id] = [];
+        }
+        if (visitedEntities[entityType][id].some(function(entity) {
+          return entity === input;
+        })) {
+          return id;
+        }
+        visitedEntities[entityType][id].push(input);
+        var processedEntity = this._processStrategy(input, parent, key);
+        Object.keys(this.schema).forEach(function(key2) {
+          if (processedEntity.hasOwnProperty(key2) && typeof processedEntity[key2] === "object") {
+            var schema3 = _this.schema[key2];
+            var resolvedSchema = typeof schema3 === "function" ? schema3(input) : schema3;
+            processedEntity[key2] = visit2(processedEntity[key2], processedEntity, key2, resolvedSchema, addEntity, visitedEntities);
+          }
+        });
+        addEntity(this, processedEntity, input, parent, key);
+        return id;
+      };
+      _proto.denormalize = function denormalize2(entity, unvisit) {
+        var _this2 = this;
+        if (isImmutable(entity)) {
+          return denormalizeImmutable(this.schema, entity, unvisit);
+        }
+        Object.keys(this.schema).forEach(function(key) {
+          if (entity.hasOwnProperty(key)) {
+            var schema3 = _this2.schema[key];
+            entity[key] = unvisit(entity[key], schema3);
+          }
+        });
+        return entity;
+      };
+      _createClass(EntitySchema2, [{
+        key: "key",
+        get: function get() {
+          return this._key;
+        }
+      }, {
+        key: "idAttribute",
+        get: function get() {
+          return this._idAttribute;
+        }
+      }]);
+      return EntitySchema2;
+    }();
+    var PolymorphicSchema = /* @__PURE__ */ function() {
+      function PolymorphicSchema2(definition, schemaAttribute) {
+        if (schemaAttribute) {
+          this._schemaAttribute = typeof schemaAttribute === "string" ? function(input) {
+            return input[schemaAttribute];
+          } : schemaAttribute;
+        }
+        this.define(definition);
+      }
+      var _proto = PolymorphicSchema2.prototype;
+      _proto.define = function define2(definition) {
+        this.schema = definition;
+      };
+      _proto.getSchemaAttribute = function getSchemaAttribute(input, parent, key) {
+        return !this.isSingleSchema && this._schemaAttribute(input, parent, key);
+      };
+      _proto.inferSchema = function inferSchema(input, parent, key) {
+        if (this.isSingleSchema) {
+          return this.schema;
+        }
+        var attr = this.getSchemaAttribute(input, parent, key);
+        return this.schema[attr];
+      };
+      _proto.normalizeValue = function normalizeValue(value, parent, key, visit2, addEntity, visitedEntities) {
+        var schema3 = this.inferSchema(value, parent, key);
+        if (!schema3) {
+          return value;
+        }
+        var normalizedValue = visit2(value, parent, key, schema3, addEntity, visitedEntities);
+        return this.isSingleSchema || normalizedValue === void 0 || normalizedValue === null ? normalizedValue : {
+          id: normalizedValue,
+          schema: this.getSchemaAttribute(value, parent, key)
+        };
+      };
+      _proto.denormalizeValue = function denormalizeValue(value, unvisit) {
+        var schemaKey = isImmutable(value) ? value.get("schema") : value.schema;
+        if (!this.isSingleSchema && !schemaKey) {
+          return value;
+        }
+        var id = this.isSingleSchema ? void 0 : isImmutable(value) ? value.get("id") : value.id;
+        var schema3 = this.isSingleSchema ? this.schema : this.schema[schemaKey];
+        return unvisit(id || value, schema3);
+      };
+      _createClass(PolymorphicSchema2, [{
+        key: "isSingleSchema",
+        get: function get() {
+          return !this._schemaAttribute;
+        }
+      }]);
+      return PolymorphicSchema2;
+    }();
+    var UnionSchema = /* @__PURE__ */ function(_PolymorphicSchema) {
+      _inheritsLoose(UnionSchema2, _PolymorphicSchema);
+      function UnionSchema2(definition, schemaAttribute) {
+        if (!schemaAttribute) {
+          throw new Error('Expected option "schemaAttribute" not found on UnionSchema.');
+        }
+        return _PolymorphicSchema.call(this, definition, schemaAttribute) || this;
+      }
+      var _proto = UnionSchema2.prototype;
+      _proto.normalize = function normalize3(input, parent, key, visit2, addEntity, visitedEntities) {
+        return this.normalizeValue(input, parent, key, visit2, addEntity, visitedEntities);
+      };
+      _proto.denormalize = function denormalize2(input, unvisit) {
+        return this.denormalizeValue(input, unvisit);
+      };
+      return UnionSchema2;
+    }(PolymorphicSchema);
+    var ValuesSchema = /* @__PURE__ */ function(_PolymorphicSchema) {
+      _inheritsLoose(ValuesSchema2, _PolymorphicSchema);
+      function ValuesSchema2() {
+        return _PolymorphicSchema.apply(this, arguments) || this;
+      }
+      var _proto = ValuesSchema2.prototype;
+      _proto.normalize = function normalize3(input, parent, key, visit2, addEntity, visitedEntities) {
+        var _this = this;
+        return Object.keys(input).reduce(function(output, key2, index) {
+          var _extends2;
+          var value = input[key2];
+          return value !== void 0 && value !== null ? _extends({}, output, (_extends2 = {}, _extends2[key2] = _this.normalizeValue(value, input, key2, visit2, addEntity, visitedEntities), _extends2)) : output;
+        }, {});
+      };
+      _proto.denormalize = function denormalize2(input, unvisit) {
+        var _this2 = this;
+        return Object.keys(input).reduce(function(output, key) {
+          var _extends3;
+          var entityOrId = input[key];
+          return _extends({}, output, (_extends3 = {}, _extends3[key] = _this2.denormalizeValue(entityOrId, unvisit), _extends3));
+        }, {});
+      };
+      return ValuesSchema2;
+    }(PolymorphicSchema);
+    var validateSchema = function validateSchema2(definition) {
+      var isArray = Array.isArray(definition);
+      if (isArray && definition.length > 1) {
+        throw new Error("Expected schema definition to be a single schema, but found " + definition.length + ".");
+      }
+      return definition[0];
+    };
+    var getValues = function getValues2(input) {
+      return Array.isArray(input) ? input : Object.keys(input).map(function(key) {
+        return input[key];
+      });
+    };
+    var normalize2 = function normalize3(schema3, input, parent, key, visit2, addEntity, visitedEntities) {
+      schema3 = validateSchema(schema3);
+      var values = getValues(input);
+      return values.map(function(value, index) {
+        return visit2(value, parent, key, schema3, addEntity, visitedEntities);
+      });
+    };
+    var denormalize = function denormalize2(schema3, input, unvisit) {
+      schema3 = validateSchema(schema3);
+      return input && input.map ? input.map(function(entityOrId) {
+        return unvisit(entityOrId, schema3);
+      }) : input;
+    };
+    var ArraySchema = /* @__PURE__ */ function(_PolymorphicSchema) {
+      _inheritsLoose(ArraySchema2, _PolymorphicSchema);
+      function ArraySchema2() {
+        return _PolymorphicSchema.apply(this, arguments) || this;
+      }
+      var _proto = ArraySchema2.prototype;
+      _proto.normalize = function normalize3(input, parent, key, visit2, addEntity, visitedEntities) {
+        var _this = this;
+        var values = getValues(input);
+        return values.map(function(value, index) {
+          return _this.normalizeValue(value, parent, key, visit2, addEntity, visitedEntities);
+        }).filter(function(value) {
+          return value !== void 0 && value !== null;
+        });
+      };
+      _proto.denormalize = function denormalize2(input, unvisit) {
+        var _this2 = this;
+        return input && input.map ? input.map(function(value) {
+          return _this2.denormalizeValue(value, unvisit);
+        }) : input;
+      };
+      return ArraySchema2;
+    }(PolymorphicSchema);
+    var _normalize = function normalize3(schema3, input, parent, key, visit2, addEntity, visitedEntities) {
+      var object = _extends({}, input);
+      Object.keys(schema3).forEach(function(key2) {
+        var localSchema = schema3[key2];
+        var resolvedLocalSchema = typeof localSchema === "function" ? localSchema(input) : localSchema;
+        var value = visit2(input[key2], input, key2, resolvedLocalSchema, addEntity, visitedEntities);
+        if (value === void 0 || value === null) {
+          delete object[key2];
+        } else {
+          object[key2] = value;
+        }
+      });
+      return object;
+    };
+    var _denormalize = function denormalize2(schema3, input, unvisit) {
+      if (isImmutable(input)) {
+        return denormalizeImmutable(schema3, input, unvisit);
+      }
+      var object = _extends({}, input);
+      Object.keys(schema3).forEach(function(key) {
+        if (object[key] != null) {
+          object[key] = unvisit(object[key], schema3[key]);
+        }
+      });
+      return object;
+    };
+    var ObjectSchema = /* @__PURE__ */ function() {
+      function ObjectSchema2(definition) {
+        this.define(definition);
+      }
+      var _proto = ObjectSchema2.prototype;
+      _proto.define = function define2(definition) {
+        this.schema = Object.keys(definition).reduce(function(entitySchema, key) {
+          var _extends2;
+          var schema3 = definition[key];
+          return _extends({}, entitySchema, (_extends2 = {}, _extends2[key] = schema3, _extends2));
+        }, this.schema || {});
+      };
+      _proto.normalize = function normalize3() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        return _normalize.apply(void 0, [this.schema].concat(args));
+      };
+      _proto.denormalize = function denormalize2() {
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        return _denormalize.apply(void 0, [this.schema].concat(args));
+      };
+      return ObjectSchema2;
+    }();
+    var visit = function visit2(value, parent, key, schema3, addEntity, visitedEntities) {
+      if (typeof value !== "object" || !value) {
+        return value;
+      }
+      if (typeof schema3 === "object" && (!schema3.normalize || typeof schema3.normalize !== "function")) {
+        var method2 = Array.isArray(schema3) ? normalize2 : _normalize;
+        return method2(schema3, value, parent, key, visit2, addEntity, visitedEntities);
+      }
+      return schema3.normalize(value, parent, key, visit2, addEntity, visitedEntities);
+    };
+    var addEntities = function addEntities2(entities2) {
+      return function(schema3, processedEntity, value, parent, key) {
+        var schemaKey = schema3.key;
+        var id = schema3.getId(value, parent, key);
+        if (!(schemaKey in entities2)) {
+          entities2[schemaKey] = {};
+        }
+        var existingEntity = entities2[schemaKey][id];
+        if (existingEntity) {
+          entities2[schemaKey][id] = schema3.merge(existingEntity, processedEntity);
+        } else {
+          entities2[schemaKey][id] = processedEntity;
+        }
+      };
+    };
+    var schema2 = {
+      Array: ArraySchema,
+      Entity: EntitySchema,
+      Object: ObjectSchema,
+      Union: UnionSchema,
+      Values: ValuesSchema
+    };
+    var normalize$1 = function normalize3(input, schema3) {
+      if (!input || typeof input !== "object") {
+        throw new Error('Unexpected input given to normalize. Expected type to be "object", found "' + (input === null ? "null" : typeof input) + '".');
+      }
+      var entities2 = {};
+      var addEntity = addEntities(entities2);
+      var visitedEntities = {};
+      var result = visit(input, input, null, schema3, addEntity, visitedEntities);
+      return {
+        entities: entities2,
+        result
+      };
+    };
+    var unvisitEntity = function unvisitEntity2(id, schema3, unvisit, getEntity, cache) {
+      var entity = getEntity(id, schema3);
+      if (entity === void 0 && schema3 instanceof EntitySchema) {
+        entity = schema3.fallback(id, schema3);
+      }
+      if (typeof entity !== "object" || entity === null) {
+        return entity;
+      }
+      if (!cache[schema3.key]) {
+        cache[schema3.key] = {};
+      }
+      if (!cache[schema3.key][id]) {
+        var entityCopy = isImmutable(entity) ? entity : _extends({}, entity);
+        cache[schema3.key][id] = entityCopy;
+        cache[schema3.key][id] = schema3.denormalize(entityCopy, unvisit);
+      }
+      return cache[schema3.key][id];
+    };
+    var getUnvisit = function getUnvisit2(entities2) {
+      var cache = {};
+      var getEntity = getEntities(entities2);
+      return function unvisit(input, schema3) {
+        if (typeof schema3 === "object" && (!schema3.denormalize || typeof schema3.denormalize !== "function")) {
+          var method2 = Array.isArray(schema3) ? denormalize : _denormalize;
+          return method2(schema3, input, unvisit);
+        }
+        if (input === void 0 || input === null) {
+          return input;
+        }
+        if (schema3 instanceof EntitySchema) {
+          return unvisitEntity(input, schema3, unvisit, getEntity, cache);
+        }
+        return schema3.denormalize(input, unvisit);
+      };
+    };
+    var getEntities = function getEntities2(entities2) {
+      var isImmutable$1 = isImmutable(entities2);
+      return function(entityOrId, schema3) {
+        var schemaKey = schema3.key;
+        if (typeof entityOrId === "object") {
+          return entityOrId;
+        }
+        if (isImmutable$1) {
+          return entities2.getIn([schemaKey, entityOrId.toString()]);
+        }
+        return entities2[schemaKey] && entities2[schemaKey][entityOrId];
+      };
+    };
+    var denormalize$1 = function denormalize2(input, schema3, entities2) {
+      if (typeof input !== "undefined") {
+        return getUnvisit(entities2)(input, schema3);
+      }
+    };
+    exports.denormalize = denormalize$1;
+    exports.normalize = normalize$1;
+    exports.schema = schema2;
+  }
+});
+
+// src/index.ts
+init_define_import_meta();
+
+// src/selectors/auth.ts
+init_define_import_meta();
+import _ from "lodash/fp.js";
+var getAuth = _.get("auth");
+var getIsLogged = _.flow(_.get("auth.id"), _.negate(_.isNil));
+var getToken = _.get("auth.token");
+
+// src/selectors/school.ts
+init_define_import_meta();
+import { makeEntitiesFilter, pipe } from "@lls/utils";
+import _2 from "lodash/fp.js";
+
+// src/selectors/crud.ts
+init_define_import_meta();
+import { createSearchSelector, makeGetAllEntities, makeGetEntityById } from "@lls/utils";
+import { useMemo } from "react";
+import { useSelector } from "react-redux";
+var crud = (entityName, { search: search31 }) => {
+  const getElements = makeGetAllEntities(entityName);
+  const makeSearchElements = () => createSearchSelector(
+    makeGetAllEntities(entityName),
+    (_state, params) => params,
+    (elements, params) => search31(params)(elements)
+  );
+  const methodName = `${entityName.charAt(0).toUpperCase()}${entityName.slice(1)}`;
+  const getElementById = makeGetEntityById(entityName);
+  const useSearch = makeUseSearch(makeSearchElements);
+  const back = {
+    [`get${methodName}`]: getElements,
+    [`search${methodName}`]: makeSearchElements(),
+    [`get${methodName.replace(/s$/, "")}`]: getElementById,
+    [`makeSearch${methodName}`]: makeSearchElements,
+    [`filter${methodName}`]: search31,
+    [`useSearch${methodName}`]: useSearch
+  };
+  return back;
+};
+var makeUseSearch = (makeSearchElements) => {
+  return (params) => {
+    const fn = useMemo(makeSearchElements, []);
+    return useSelector((state) => fn(state, params));
+  };
+};
+
+// src/selectors/school.ts
+var search = ({ ids, academyIds, sortByQuery }) => {
+  return (schools) => pipe(
+    schools,
+    makeEntitiesFilter({ id: ids, academy: academyIds }),
+    _2.isFunction(sortByQuery) ? sortByQuery : sortByQuery ? _2.sortBy(sortByQuery) : _2.identity
+  );
+};
+var { getSchools, getSchool, useSearchSchools } = crud("schools", {
+  search
+});
+
+// src/selectors/book.ts
+init_define_import_meta();
+import { createSearchSelector as createSearchSelector2, makeEntitiesFilter as makeEntitiesFilter2, makeGetEntityById as makeGetEntityById2, pipe as pipe2 } from "@lls/utils";
+import _3 from "lodash/fp.js";
+var search2 = ({
+  ids,
+  levelIds,
+  subjectIds,
+  years,
+  isValid,
+  isWorkbook,
+  isWorkplan,
+  hasNoTeacherBook,
+  sortByQuery,
+  hasNewDesign,
+  slugs,
+  uris,
+  publishers,
+  isRenewed,
+  isPrimary
+}) => {
+  return (books) => pipe2(
+    books,
+    makeEntitiesFilter2({
+      id: ids,
+      year: years,
+      levels: levelIds,
+      subjects: subjectIds,
+      valid: isValid,
+      publisher: publishers,
+      hasNewDesign,
+      isWorkbook,
+      isWorkplan,
+      hasNoTeacherBook,
+      slug: slugs,
+      uri: uris,
+      isRenewed,
+      isPrimary
+    }),
+    _3.isFunction(sortByQuery) ? sortByQuery : sortByQuery ? _3.sortBy(sortByQuery) : _3.identity
+  );
+};
+var { getBooks, getBook, filterBooks, useSearchBooks, makeSearchBooks } = crud("books", {
+  search: search2
+});
+var makeSearchValidBooks = () => createSearchSelector2(makeSearchBooks(), (books) => _3.filter({ valid: true, hasNewDesign: true }, books));
+var useSearchValidBooks = makeUseSearch(makeSearchValidBooks);
+var makeGetBook = () => makeGetEntityById2("books");
+
+// src/selectors/user.ts
+init_define_import_meta();
+var import_reselect = __toESM(require_lib(), 1);
+import { makeEntitiesFilter as makeEntitiesFilter3 } from "@lls/utils";
+var search3 = ({ ids, schoolIds }) => makeEntitiesFilter3({
+  schools: schoolIds,
+  id: ids
+});
+var { getUsers, getUser, useSearchUsers } = crud("users", {
+  search: search3
+});
+var makeGetCurrentUser = () => (0, import_reselect.createSelector)(getAuth, getUsers, (auth2, users) => users?.find((user2) => user2?.id === auth2?.id));
+var getCurrentUser = makeGetCurrentUser();
+
+// src/selectors/chapter.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter4, pipe as pipe3 } from "@lls/utils";
+import _4 from "lodash/fp.js";
+var search4 = ({ bookIds, ids, hasTeacherBook, sortByQuery }) => (chapters) => pipe3(
+  chapters,
+  makeEntitiesFilter4(
+    {
+      book: bookIds,
+      id: ids
+    },
+    !_4.isNil(hasTeacherBook) && ((chapter2) => !!chapter2?.teacherBook === hasTeacherBook)
+  ),
+  _4.isFunction(sortByQuery) ? sortByQuery : sortByQuery ? _4.sortBy(sortByQuery) : _4.identity
+);
+var { getChapters, getChapter, useSearchChapters } = crud("chapters", {
+  search: search4
+});
+
+// src/selectors/page.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter5, pipe as pipe4 } from "@lls/utils";
+import _5 from "lodash/fp.js";
+var search5 = ({
+  ids,
+  chapterIds,
+  isValid,
+  oldLessonIds,
+  premium,
+  thematicNames,
+  bookIds,
+  isOriginal,
+  hasNewDesign,
+  slugs,
+  isLearningAssessment,
+  isCreatedFromScratch,
+  userIds,
+  parentIds,
+  originalPageIds,
+  sharedUserIds,
+  sharedGroups,
+  isDraft,
+  isParentCreatedFromScratch,
+  updatedAfter,
+  sortByQuery
+}) => {
+  let pageById = false;
+  return (pages) => pipe4(
+    pages,
+    makeEntitiesFilter5(
+      {
+        id: ids,
+        chapter: chapterIds,
+        valid: isValid,
+        isOriginal,
+        hasNewDesign,
+        slug: slugs,
+        oldLesson: oldLessonIds,
+        isLearningAssessment,
+        isCreatedFromScratch,
+        premium,
+        thematicName: thematicNames,
+        book: bookIds,
+        parent: parentIds,
+        user: userIds,
+        originalPage: originalPageIds,
+        sharedUsers: sharedUserIds,
+        sharedGroups,
+        isDraft
+      },
+      isParentCreatedFromScratch && ((page2, pages2) => {
+        pageById = pageById || _5.keyBy("id", pages2);
+        return !!_5.get([page2?.originalPage, "isCreatedFromScratch"], pageById);
+      }),
+      updatedAfter && _5.flow(_5.get("updatedAt"), (date) => new Date(date).getTime() - updatedAfter.getTime() >= 0)
+    ),
+    _5.isFunction(sortByQuery) ? sortByQuery : sortByQuery ? _5.sortBy(sortByQuery) : _5.identity
+  );
+};
+var { getPages, getPage, filterPages, useSearchPages, makeSearchPages } = crud("pages", {
+  search: search5
+});
+var { getDrafts, getDraft, useSearchDrafts } = crud("drafts", { search: search5 });
+var searchModifiedPages = (params) => {
+  return (pages) => search5({ ...params, isOriginal: false })(pages);
+};
+var { useSearchPages: useSearchModifiedPages } = crud("pages", { search: searchModifiedPages });
+
+// src/selectors/collection.ts
+init_define_import_meta();
+import _6 from "lodash/fp.js";
+var search6 = (_params) => _6.identity;
+var { getCollections, getCollection, useSearchCollections } = crud("collections", {
+  search: search6
+});
+
+// src/selectors/communityProject.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter6 } from "@lls/utils";
+var search7 = ({
+  slugs,
+  isFeatured,
+  projectTypes
+}) => makeEntitiesFilter6({
+  slug: slugs,
+  isFeatured,
+  projectTypes
+});
+var { getCommunityProjects, getCommunityProject, useSearchCommunityProjects } = crud("communityProjects", {
+  search: search7
+});
+
+// src/selectors/contact.ts
+init_define_import_meta();
+import _7 from "lodash/fp.js";
+var search8 = (_params) => _7.identity;
+var { getContacts, getContact, useSearchContacts } = crud("contacts", {
+  search: search8
+});
+
+// src/selectors/copyNotification.ts
+init_define_import_meta();
+import { createSearchSelector as createSearchSelector3, makeEntitiesFilter as makeEntitiesFilter7, makeGetAllEntities as makeGetAllEntities2 } from "@lls/utils";
+var search9 = ({ ids, read, pageIds }) => {
+  return makeEntitiesFilter7({ read, id: ids, page: pageIds });
+};
+var makeSearchCopyNotifications = () => createSearchSelector3(
+  [makeGetCurrentUser(), makeGetAllEntities2("copyNotifications"), (_20, params) => params],
+  (currentUser, copyNotifications, { pageIds, read }) => {
+    const ids = currentUser?.copyNotifications;
+    return search9({ ids, read, pageIds })(copyNotifications);
+  }
+);
+var useSearchCopyNotifications = makeUseSearch(makeSearchCopyNotifications);
+
+// src/selectors/document.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter8 } from "@lls/utils";
+var search10 = ({
+  ids,
+  uuids,
+  resourceIds,
+  levelIds,
+  formats,
+  documentTypes,
+  subDocumentTypes
+}) => {
+  return makeEntitiesFilter8({
+    id: ids,
+    resourceId: resourceIds,
+    levels: levelIds,
+    uuidV2: uuids,
+    format: formats,
+    documentType: documentTypes,
+    subDocumentType: subDocumentTypes
+  });
+};
+var { useSearchDocuments, getDocument } = crud("documents", {
+  search: search10
+});
+
+// src/selectors/drawerNotification.ts
+init_define_import_meta();
+import { createSearchSelector as createSearchSelector4, makeEntitiesFilter as makeEntitiesFilter9, makeGetAllEntities as makeGetAllEntities3 } from "@lls/utils";
+var search11 = ({ ids, read, pageIds }) => {
+  return makeEntitiesFilter9({ read, id: ids, page: pageIds });
+};
+var makeSearchDrawerNotifications = () => createSearchSelector4(
+  [makeGetCurrentUser(), makeGetAllEntities3("drawerNotifications"), (_20, params) => params],
+  (currentUser, drawerNotifications, { read, pageIds }) => {
+    const ids = currentUser?.drawerNotifications;
+    return search11({ ids, read, pageIds })(drawerNotifications);
+  }
+);
+var useSearchDrawerNotifications = makeUseSearch(makeSearchDrawerNotifications);
+
+// src/selectors/faq.ts
+init_define_import_meta();
+import { makeGetAllEntities as makeGetAllEntities4 } from "@lls/utils";
+var getFaqs = makeGetAllEntities4("faq");
+
+// src/selectors/garDivision.ts
+init_define_import_meta();
+import _8 from "lodash/fp.js";
+var search12 = (_params) => _8.identity;
+var { getGarDivisions, getGarDivision, useSearchGarDivisions } = crud("garDivisions", {
+  search: search12
+});
+
+// src/selectors/group.ts
+init_define_import_meta();
+var import_reselect2 = __toESM(require_lib(), 1);
+import { makeEntitiesFilter as makeEntitiesFilter10 } from "@lls/utils";
+import _9 from "lodash/fp.js";
+var search13 = ({ ownerIds }) => _9.flow(makeEntitiesFilter10({ owner: ownerIds }), _9.orderBy("createdAt", ["desc"]));
+var { getGroups, getGroup, useSearchGroups } = crud("groups", {
+  search: search13
+});
+var getUserGroups = (0, import_reselect2.createSelector)(
+  [getGroups, getCurrentUser],
+  (groups, currentUser) => search13({ ownerIds: [currentUser?.id] })(groups)
+);
+
+// src/selectors/level.ts
+init_define_import_meta();
+var import_reselect3 = __toESM(require_lib(), 1);
+import { createSearchSelector as createSearchSelector5, makeEntitiesFilter as makeEntitiesFilter12, makeGetAllEntities as makeGetAllEntities5 } from "@lls/utils";
+import _10 from "lodash/fp.js";
+
+// src/selectors/schoolType.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter11 } from "@lls/utils";
+var search14 = ({ slugs }) => makeEntitiesFilter11({ slug: slugs });
+var { getSchoolTypes, getSchoolType, useSearchSchoolTypes, makeSearchSchoolTypes, searchSchoolTypes } = crud(
+  "schoolTypes",
+  {
+    search: search14
+  }
+);
+
+// src/selectors/level.ts
+var search15 = ({
+  ids,
+  slugs,
+  isPreSchool,
+  isMiddleSchool,
+  isHighSchool,
+  isProHighSchool,
+  isGenHighSchool,
+  isElementarySchool,
+  schoolTypes
+}) => _10.flow(
+  makeEntitiesFilter12({
+    id: ids,
+    slug: slugs,
+    isPreSchool,
+    isMiddleSchool,
+    isHighSchool,
+    isProHighSchool,
+    isGenHighSchool,
+    isElementarySchool,
+    schoolTypes
+  }),
+  _10.orderBy("order", "desc")
+);
+var makeSearchLevels = () => {
+  const searchSchoolTypes2 = makeSearchSchoolTypes();
+  return createSearchSelector5(
+    makeGetAllEntities5("levels"),
+    (state, { schoolTypes }) => schoolTypes ? searchSchoolTypes2(state, { slugs: schoolTypes }) : void 0,
+    (_state, params) => params,
+    (levels, schoolTypes, params) => search15({ ...params, schoolTypes: schoolTypes?.length ? schoolTypes?.map(({ id }) => id) : void 0 })(levels)
+  );
+};
+var crudLevels = crud("levels", { search: search15 });
+var { getLevel, searchLevels } = crudLevels;
+var getLevels = (0, import_reselect3.createSelector)(
+  crudLevels.getLevels,
+  _10.orderBy("order", "desc")
+);
+var useSearchLevels = makeUseSearch(makeSearchLevels);
+
+// src/selectors/mainNotification.ts
+init_define_import_meta();
+var import_reselect4 = __toESM(require_lib(), 1);
+import { makeEntitiesFilter as makeEntitiesFilter13, makeGetAllEntities as makeGetAllEntities6 } from "@lls/utils";
+import _11 from "lodash/fp.js";
+var search16 = ({ ids }) => makeEntitiesFilter13({ id: ids });
+var getMainNotifications = (0, import_reselect4.createSelector)(
+  [_11.flow(makeGetCurrentUser(), _11.get("mainNotifications")), makeGetAllEntities6("mainNotifications")],
+  (userNotifications, notifications) => search16({ ids: userNotifications })(notifications)
+);
+
+// src/selectors/news.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter14 } from "@lls/utils";
+var search17 = ({ ids }) => makeEntitiesFilter14({ id: ids });
+var {
+  getNews: getAllNews,
+  getNew: getNews,
+  useSearchNews
+} = crud("news", {
+  search: search17
+});
+
+// src/selectors/panorama.ts
+init_define_import_meta();
+import { makeGetEntityById as makeGetEntityById3 } from "@lls/utils";
+var getPanorama = makeGetEntityById3("panoramas");
+
+// src/selectors/premiumResource.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter15 } from "@lls/utils";
+var search18 = ({ bookIds }) => makeEntitiesFilter15({ book: bookIds });
+var { getPremiumResources, getPremiumResource, useSearchPremiumResources } = crud("premiumResources", {
+  search: search18
+});
+
+// src/selectors/lexicalFlower.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter16 } from "@lls/utils";
+var search19 = ({ ids }) => makeEntitiesFilter16({ id: ids });
+var { getLexicalFlowers, useSearchLexicalFlowers } = crud("lexicalFlowers", {
+  search: search19
+});
+
+// src/selectors/product.ts
+init_define_import_meta();
+import _12 from "lodash/fp.js";
+import { createSearchSelector as createSearchSelector6, makeEntitiesFilter as makeEntitiesFilter17, makeGetAllEntities as makeGetAllEntities7 } from "@lls/utils";
+var getProducts = makeGetAllEntities7("products");
+var search20 = ({
+  ids,
+  eans,
+  isAdoptant,
+  isSupportPlus,
+  levelIds,
+  subjectIds,
+  productTypes
+}) => {
+  let bookIds;
+  const filter = makeEntitiesFilter17(
+    {
+      id: ids,
+      ean: eans,
+      isAdoptant,
+      isSupportPlus,
+      productType: productTypes
+    },
+    levelIds || subjectIds ? (product2) => !!product2?.books?.some((bookId) => bookIds.has(bookId)) : false
+  );
+  return (products, books) => {
+    bookIds = new Set(_12.flow(_12.map("id"), _12.map(_12.parseInt(10)))(books));
+    return filter(products);
+  };
+};
+var makeSearchProducts = () => {
+  const searchBooks = makeSearchBooks();
+  return createSearchSelector6(
+    makeGetAllEntities7("products"),
+    (state, { levelIds, subjectIds }) => searchBooks(state, { levelIds, subjectIds }),
+    (_state, params) => params,
+    (products, books, params) => search20(params)(products, books)
+  );
+};
+var useSearchProducts = makeUseSearch(makeSearchProducts);
+
+// src/selectors/resource.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter18 } from "@lls/utils";
+var search21 = ({ chapterIds }) => makeEntitiesFilter18({
+  chapter: chapterIds
+});
+var { getResources, getResource, useSearchResources } = crud("resources", {
+  search: search21
+});
+
+// src/selectors/sharedPage.ts
+init_define_import_meta();
+import { createSearchSelector as createSearchSelector7, makeEntitiesFilter as makeEntitiesFilter19 } from "@lls/utils";
+import _13 from "lodash/fp.js";
+var search22 = ({
+  parentIds,
+  userIds,
+  bookIds,
+  isCreatedFromScratch,
+  isLearningAssessment,
+  ids
+}) => makeEntitiesFilter19({
+  id: ids,
+  parent: parentIds,
+  user: userIds,
+  book: bookIds,
+  isLearningAssessment,
+  isCreatedFromScratch
+});
+var { getSharedPages, getSharedPage, useSearchSharedPages } = crud("sharedPages", {
+  search: search22
+});
+var makeSearchCurrentUserSharedPages = () => createSearchSelector7(
+  getCurrentUser,
+  getSharedPages,
+  (__, params) => params,
+  (user2, sharedPages, params) => {
+    const sharedUserPageIds = user2?.sharedPages ?? [];
+    return search22({ ...params, ids: _13.intersection(sharedUserPageIds, params.ids || sharedUserPageIds) })(sharedPages);
+  }
+);
+var useSearchCurrentUserSharedPages = makeUseSearch(makeSearchCurrentUserSharedPages);
+
+// src/selectors/student.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter20 } from "@lls/utils";
+var search23 = ({ ids }) => makeEntitiesFilter20({ id: ids });
+var { getStudents, getStudent, useSearchStudents } = crud("students", {
+  search: search23
+});
+
+// src/selectors/subject.ts
+init_define_import_meta();
+import { limitToTeacherSubjects, makeEntitiesFilter as makeEntitiesFilter21, pipe as pipe5 } from "@lls/utils";
+import _14 from "lodash/fp.js";
+var search24 = ({
+  ids,
+  slugs,
+  isTeacherSubject,
+  hasNewsletterUrl,
+  schoolTypes,
+  hasBooks,
+  names,
+  sortByQuery
+}) => (subjects) => pipe5(
+  subjects,
+  makeEntitiesFilter21(
+    {
+      id: ids,
+      slug: slugs,
+      name: names,
+      hasBooks,
+      schoolTypes
+    },
+    !_14.isNil(hasNewsletterUrl) && ((subject2) => Boolean(subject2?.newsletterUrl) === hasNewsletterUrl)
+  ),
+  (subjects2) => _14.isNil(isTeacherSubject) ? subjects2 : limitToTeacherSubjects(subjects2),
+  _14.isFunction(sortByQuery) ? sortByQuery : sortByQuery ? _14.sortBy(sortByQuery) : _14.identity
+);
+var { getSubjects, getSubject, useSearchSubjects, makeSearchSubjects } = crud("subjects", {
+  search: search24
+});
+
+// src/selectors/teacher.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter22 } from "@lls/utils";
+var search25 = ({ ids, schoolIds }) => makeEntitiesFilter22({
+  id: ids,
+  schools: schoolIds
+});
+var { getTeachers, getTeacher, useSearchTeachers } = crud("teachers", {
+  search: search25
+});
+
+// src/selectors/method.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter23 } from "@lls/utils";
+var search26 = ({ ids, uris }) => makeEntitiesFilter23({ id: ids, uri: uris });
+var { getMethods, useSearchMethods } = crud("methods", {
+  search: search26
+});
+
+// src/selectors/tool.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter24 } from "@lls/utils";
+var search27 = ({ ids, locked, bookIds }) => makeEntitiesFilter24({
+  id: ids,
+  locked,
+  books: bookIds
+});
+var { getTools, getTool, useSearchTools } = crud("tools", {
+  search: search27
+});
+
+// src/selectors/builderIo.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter25 } from "@lls/utils";
+var search28 = ({ modelIds, subjects, schoolTypes }) => makeEntitiesFilter25(
+  {
+    modelId: modelIds
+  },
+  subjects && ((builderIo2) => !!builderIo2?.data?.subjects?.some((x) => subjects.includes(x))),
+  schoolTypes && ((builderIo2) => !!builderIo2?.data?.schoolTypes?.some((x) => schoolTypes.includes(x)))
+);
+var { getBuilderIos, getBuilderIo, useSearchBuilderIos } = crud("builderIos", {
+  search: search28
+});
+
+// src/selectors/circonscription.ts
+init_define_import_meta();
+import _15 from "lodash/fp.js";
+var search29 = (_params) => _15.identity;
+var { getCirconscriptions } = crud("circonscriptions", {
+  search: search29
+});
+
+// src/selectors/documentType.ts
+init_define_import_meta();
+import { makeEntitiesFilter as makeEntitiesFilter26 } from "@lls/utils";
+var search30 = ({ ids }) => {
+  return makeEntitiesFilter26({
+    id: ids
+  });
+};
+var searchSubDocumentType = ({
+  ids
+}) => {
+  return makeEntitiesFilter26({
+    id: ids
+  });
+};
+var { getSubDocumentTypes, useSearchSubDocumentTypes } = crud("subDocumentTypes", {
+  search: searchSubDocumentType
+});
+var { getDocumentTypes, getDocumentType, useSearchDocumentTypes } = crud("documentTypes", {
+  search: search30
+});
+
+// src/selectors/globalRights.ts
+init_define_import_meta();
+import _16 from "lodash/fp.js";
+var getGlobalRights = _16.get("entities.globalRights");
+
+// src/reducers/entities.ts
+init_define_import_meta();
+import { makeReducer } from "@lls/utils";
+import _17 from "lodash/fp.js";
+
+// src/actions/index.ts
+init_define_import_meta();
+import { makeActionCreator } from "@lls/utils";
+var actionTypes = {
+  DELETE_ENTITY: "DELETE_ENTITY",
+  UPDATE_ENTITY: "UPDATE_ENTITY",
+  SET_ENTITY: "SET_ENTITY",
+  SET_ENTITIES: "SET_ENTITIES",
+  RESET_AUTH: "RESET_AUTH",
+  SET_AUTH: "SET_AUTH"
+};
+var deleteEntity = makeActionCreator(actionTypes.DELETE_ENTITY);
+var updateEntity = makeActionCreator(actionTypes.UPDATE_ENTITY);
+var setEntity = makeActionCreator(actionTypes.SET_ENTITY);
+var setEntities = makeActionCreator(actionTypes.SET_ENTITIES);
+var setAuth = makeActionCreator(actionTypes.SET_AUTH);
+var resetAuth = makeActionCreator(actionTypes.RESET_AUTH);
+
+// src/reducers/entities.ts
+var deleteEntityReducer = (state, payload) => {
+  const { path } = payload;
+  return _17.omit(path, state);
+};
+var updateEntityReducer = (state, payload) => {
+  const { path, entity } = payload;
+  const currentEntity = _17.get(path, state);
+  return _17.set(path, _17.merge(currentEntity, entity), state);
+};
+var setEntityReducer = (state, payload) => {
+  const { path, entity } = payload;
+  return _17.set(path, entity, state);
+};
+var setEntitiesReducer = (state, payload) => {
+  if (typeof payload !== "object") return state;
+  const stateDrafts = {};
+  Object.keys(payload).forEach((entityName) => {
+    const entities2 = payload[entityName];
+    const entityDraft = {};
+    if (!entities2) {
+      return;
+    }
+    Object.keys(entities2).forEach((id) => {
+      const entity = entities2[id];
+      if (!state[entityName]?.[id]) {
+        entityDraft[id] = entity;
+      } else {
+        if (typeof entity === "undefined") {
+          return;
+        }
+        const diff = Object.keys(entity).some((prop) => {
+          const value = entity[prop];
+          if (!_17.isEqual(state[entityName]?.[id]?.[prop], value)) {
+            return true;
+          }
+        });
+        if (diff) {
+          entityDraft[id] = Object.assign({}, state[entityName]?.[id], entity);
+        }
+      }
+    });
+    if (Object.keys(entityDraft).length !== 0) {
+      stateDrafts[entityName] = { ...state[entityName], ...entityDraft };
+    }
+  });
+  if (Object.keys(stateDrafts).length !== 0) {
+    return { ...state, ...stateDrafts };
+  }
+  return state;
+};
+var entities = makeReducer(
+  {},
+  {
+    [actionTypes.DELETE_ENTITY]: deleteEntityReducer,
+    [actionTypes.UPDATE_ENTITY]: updateEntityReducer,
+    [actionTypes.SET_ENTITY]: setEntityReducer,
+    [actionTypes.SET_ENTITIES]: setEntitiesReducer
+  }
+);
+var entities_default = entities;
+
+// src/reducers/auth.ts
+init_define_import_meta();
+import { makeReducer as makeReducer2 } from "@lls/utils";
+import _18 from "lodash/fp.js";
+var initialState = {
+  id: void 0,
+  role: null,
+  token: null,
+  isStudent: null,
+  isTeacher: null,
+  isPremium: null,
+  userPages: null,
+  username: null,
+  llsUserId: null
+};
+var auth = makeReducer2(initialState, {
+  [actionTypes.SET_AUTH]: _18.assign,
+  [actionTypes.RESET_AUTH]: _18.constant(initialState)
+});
+var auth_default = auth;
+
+// src/schema/index.ts
+init_define_import_meta();
+var import_normalizr = __toESM(require_normalizr(), 1);
+import _19 from "lodash/fp.js";
+var document = new import_normalizr.schema.Entity("documents");
+var documentType = new import_normalizr.schema.Entity("documentTypes");
+var subDocumentType = new import_normalizr.schema.Entity("subDocumentTypes");
+var subject = new import_normalizr.schema.Entity("subjects");
+var level = new import_normalizr.schema.Entity("levels");
+var book = new import_normalizr.schema.Entity("books");
+var tool = new import_normalizr.schema.Entity("tools");
+var chapter = new import_normalizr.schema.Entity("chapters");
+var page = new import_normalizr.schema.Entity("pages");
+var resource = new import_normalizr.schema.Entity("resources");
+var user = new import_normalizr.schema.Entity("users");
+var school = new import_normalizr.schema.Entity("schools");
+var teacher = new import_normalizr.schema.Entity("teachers");
+var faq = new import_normalizr.schema.Entity("faq");
+var product = new import_normalizr.schema.Entity("products");
+var communityProjects = new import_normalizr.schema.Entity("communityProjects");
+var builderIo = new import_normalizr.schema.Entity("builderIos");
+var lexicalFlower = new import_normalizr.schema.Entity("lexicalFlowers");
+var globalRights = new import_normalizr.schema.Entity(
+  "globalRights",
+  {},
+  {
+    idAttribute: (_20, __, key) => key
+    // Use keys from globalRights(anonymous, classroom, connected, teacher) as Id
+  }
+);
+var grammarRule = new import_normalizr.schema.Entity("grammarRules", {}, { idAttribute: "objectID" });
+var mainNotification = new import_normalizr.schema.Entity("mainNotifications");
+var explorerResult = new import_normalizr.schema.Entity("explorerResults", {}, { idAttribute: "resourceId" });
+var drawerNotification = new import_normalizr.schema.Entity("drawerNotifications");
+var copyNotification = new import_normalizr.schema.Entity("copyNotifications");
+var quote = new import_normalizr.schema.Entity("quotes");
+var group = new import_normalizr.schema.Entity("groups");
+var method = new import_normalizr.schema.Entity("methods");
+var analytic = new import_normalizr.schema.Entity("analytics");
+var contact = new import_normalizr.schema.Entity("contacts");
+var collection = new import_normalizr.schema.Entity("collections");
+var sharedPage = new import_normalizr.schema.Entity("sharedPages");
+var student = new import_normalizr.schema.Entity("students");
+var news = new import_normalizr.schema.Entity("news");
+var schoolType = new import_normalizr.schema.Entity("schoolTypes");
+var panorama = new import_normalizr.schema.Entity("panoramas");
+var premiumResource = new import_normalizr.schema.Entity("premiumResources");
+var garDivision = new import_normalizr.schema.Entity("garDivisions");
+var circonscription = new import_normalizr.schema.Entity("circonscriptions");
+var define = (el, scheme) => {
+  el.define(scheme);
+  return scheme;
+};
+var bookSchema = define(book, {
+  chapters: [chapter],
+  collection,
+  firstValidPage: page,
+  levels: [level],
+  news: [news],
+  oldBook: book,
+  premiumResources: [premiumResource],
+  revisionPages: [page],
+  subjects: [subject],
+  textbooks: [book],
+  educationalGuides: [book],
+  tools: [tool],
+  workbooks: [book],
+  workplans: [book]
+});
+var garDivisionSchema = define(garDivision, {
+  students: [user],
+  school
+});
+var documentTypeSchema = define(documentType, {
+  subTypes: [subDocumentType]
+});
+var documentSchema = define(document, {
+  page,
+  levels: [level],
+  documentType,
+  subDocumentType
+});
+var chapterSchema = define(chapter, {
+  book,
+  oldBook: book,
+  oldChapter: chapter,
+  pages: [page],
+  resources: [resource]
+});
+var pageSchema = define(page, {
+  book,
+  chapter,
+  oldBook: book,
+  oldChapter: chapter,
+  oldLesson: page,
+  originalPage: page,
+  parent: page,
+  sharedGroups: [group],
+  sharedTeacher: user,
+  sharedUsers: [user],
+  user
+});
+var userSchema = define(user, {
+  books: [book],
+  booksV2: [book],
+  contacts: [contact],
+  copies: [page],
+  copyNotifications: [copyNotification],
+  drawerNotifications: [drawerNotification],
+  garDivisions: [garDivision],
+  groups: [group],
+  lastBooksViewed: [book],
+  lastPagesViewed: [page],
+  levels: [level],
+  mainNotifications: [mainNotification],
+  pages: [page],
+  schools: [school],
+  sharedPages: [sharedPage],
+  students: [student],
+  subjects: [subject],
+  teachers: [teacher],
+  userPages: [page],
+  userBookPages: [page],
+  lexicalFlowers: { hits: [lexicalFlower] }
+});
+var notificationSchema = define(mainNotification, { page });
+drawerNotification.define({ page });
+copyNotification.define({ page });
+var resourceSchema = define(resource, {
+  chapter,
+  page
+});
+var toolSchema = define(tool, {
+  books: [book]
+});
+var sharedPageSchema = define(sharedPage, {
+  user,
+  chapter,
+  parent: page,
+  book,
+  originalPage: page
+});
+var studentSchema = define(student, {
+  levels: [level]
+});
+var teacherSchema = define(teacher, {
+  schools: [school],
+  subjects: [subject]
+});
+var productSchema = define(product, {
+  books: [book]
+});
+var groupSchema = define(group, {
+  owner: teacher,
+  students: [student]
+});
+var schoolSchema = define(school, {
+  groups: [group]
+});
+var methodSchema = define(method, {
+  book
+});
+var newsSchema = define(news, {
+  books: [book],
+  subjects: [subject],
+  levels: [level]
+});
+var premiumResourceSchema = define(premiumResource, {
+  book
+});
+var levelSchema = define(level, {
+  schoolTypes: [schoolType]
+});
+var querySchema = {
+  viewer: {
+    addCorrectionsToGroup: group,
+    addCorrectionsToStudents: page,
+    addPageAppreciation: page,
+    addStudentToGroup: group,
+    books: { hits: [book] },
+    methods: { hits: [method] },
+    chapters: { hits: [chapter] },
+    createEstimate: quote,
+    createGroup: group,
+    createPage: page,
+    createUser: user,
+    createLexicalFlower: lexicalFlower,
+    documents: { hits: [document] },
+    documentTypes: { hits: [documentType] },
+    subDocumentTypes: { hits: [subDocumentType] },
+    explorerResults: [explorerResult],
+    levels: [level],
+    globalRights: new import_normalizr.schema.Values(globalRights),
+    me: user,
+    // mutations
+    pages: { hits: [page] },
+    panoramas: [panorama],
+    parents: { hits: [page] },
+    //pages alias
+    product: { hits: [product] },
+    schoolTypes: { hits: [schoolType] },
+    sharePageToGroup: page,
+    sharePageToUsers: page,
+    subjects: { hits: [subject] },
+    updateCopyNotification: copyNotification,
+    updateDrawerNotification: drawerNotification,
+    updateGroup: group,
+    updateMainNotification: mainNotification,
+    updatePage: page,
+    updateTrialUser: user,
+    updateUserLastActivitySeenAt: user,
+    updateUser: user,
+    updateLexicalFlower: lexicalFlower
+  },
+  auth: {
+    user
+  },
+  marketing: {
+    addLikeFaq: faq,
+    communityProjects: [communityProjects],
+    createAnalytics: analytic,
+    faq: [faq],
+    builderIos: [builderIo],
+    circonscriptions: [circonscription]
+  },
+  static: {
+    projetVoltaire: {
+      grammarRules: [grammarRule]
+    }
+  }
+};
+var normalizeData = _19.flow((data) => (0, import_normalizr.normalize)(data, querySchema));
+export {
+  auth_default as authReducer,
+  entities_default as entitiesReducer,
+  filterBooks,
+  filterPages,
+  getAllNews,
+  getAuth,
+  getBook,
+  getBooks,
+  getBuilderIo,
+  getBuilderIos,
+  getChapter,
+  getChapters,
+  getCirconscriptions,
+  getCollection,
+  getCollections,
+  getCommunityProject,
+  getCommunityProjects,
+  getContact,
+  getContacts,
+  getCurrentUser,
+  getDocument,
+  getDocumentType,
+  getDocumentTypes,
+  getDraft,
+  getDrafts,
+  getFaqs,
+  getGarDivision,
+  getGarDivisions,
+  getGlobalRights,
+  getGroup,
+  getGroups,
+  getIsLogged,
+  getLevel,
+  getLevels,
+  getLexicalFlowers,
+  getMainNotifications,
+  getMethods,
+  getNews,
+  getPage,
+  getPages,
+  getPanorama,
+  getPremiumResource,
+  getPremiumResources,
+  getProducts,
+  getResource,
+  getResources,
+  getSchool,
+  getSchoolType,
+  getSchoolTypes,
+  getSchools,
+  getSharedPage,
+  getSharedPages,
+  getStudent,
+  getStudents,
+  getSubDocumentTypes,
+  getSubject,
+  getSubjects,
+  getTeacher,
+  getTeachers,
+  getToken,
+  getTool,
+  getTools,
+  getUser,
+  getUserGroups,
+  getUsers,
+  makeGetBook,
+  makeGetCurrentUser,
+  makeSearchBooks,
+  makeSearchDrawerNotifications,
+  makeSearchLevels,
+  makeSearchPages,
+  makeSearchSchoolTypes,
+  makeSearchSubjects,
+  makeSearchValidBooks,
+  makeUseSearch,
+  normalizeData,
+  querySchema,
+  searchLevels,
+  searchSchoolTypes,
+  setEntitiesReducer,
+  useSearchBooks,
+  useSearchBuilderIos,
+  useSearchChapters,
+  useSearchCollections,
+  useSearchCommunityProjects,
+  useSearchContacts,
+  useSearchCopyNotifications,
+  useSearchCurrentUserSharedPages,
+  useSearchDocumentTypes,
+  useSearchDocuments,
+  useSearchDrafts,
+  useSearchDrawerNotifications,
+  useSearchGarDivisions,
+  useSearchGroups,
+  useSearchLevels,
+  useSearchLexicalFlowers,
+  useSearchMethods,
+  useSearchModifiedPages,
+  useSearchNews,
+  useSearchPages,
+  useSearchPremiumResources,
+  useSearchProducts,
+  useSearchResources,
+  useSearchSchoolTypes,
+  useSearchSchools,
+  useSearchSharedPages,
+  useSearchStudents,
+  useSearchSubDocumentTypes,
+  useSearchSubjects,
+  useSearchTeachers,
+  useSearchTools,
+  useSearchUsers,
+  useSearchValidBooks
+};