{"version":3,"file":"static/chunks/266-1c293b12a92efe5b.js","mappings":"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","sources":["webpack://_N_E/../../node_modules/contentful-resolve-response/dist/esm/index.js","webpack://_N_E/../../node_modules/contentful-resolve-response/node_modules/fast-copy/dist/fast-copy.js"],"sourcesContent":["var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"]) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); } }; }();\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nimport copy from 'fast-copy';\n\nvar UNRESOLVED_LINK = {}; // unique object to avoid polyfill bloat using Symbol()\n\n/**\n * isLink Function\n * Checks if the object has sys.type \"Link\"\n * @param object\n */\nvar isLink = function isLink(object) {\n  return object && object.sys && object.sys.type === 'Link';\n};\n\n/**\n * isResourceLink Function\n * Checks if the object has sys.type \"ResourceLink\"\n * @param object\n */\nvar isResourceLink = function isResourceLink(object) {\n  return object && object.sys && object.sys.type === 'ResourceLink';\n};\n\n/**\n * Creates a key with spaceId and a key without for entityMap\n *\n * @param {*} sys\n * @param {String} sys.type\n * @param {String} sys.id\n * @param {*} sys.space\n * @param {*} sys.space.sys\n * @param {String} sys.space.id\n * @return {string[]}\n */\nvar makeEntityMapKeys = function makeEntityMapKeys(sys) {\n  if (sys.space && sys.environment) {\n    return [sys.type + '!' + sys.id, sys.space.sys.id + '!' + sys.environment.sys.id + '!' + sys.type + '!' + sys.id];\n  }\n\n  return [sys.type + '!' + sys.id];\n};\n\n/**\n * Looks up in entityMap\n *\n * @param entityMap\n * @param {*} linkData\n * @param {String} linkData.type\n * @param {String} linkData.linkType\n * @param {String} linkData.id\n * @param {String} linkData.urn\n * @return {String}\n */\nvar lookupInEntityMap = function lookupInEntityMap(entityMap, linkData) {\n  var entryId = linkData.entryId,\n      linkType = linkData.linkType,\n      spaceId = linkData.spaceId,\n      environmentId = linkData.environmentId;\n\n\n  if (spaceId && environmentId) {\n    return entityMap.get(spaceId + '!' + environmentId + '!' + linkType + '!' + entryId);\n  }\n\n  return entityMap.get(linkType + '!' + entryId);\n};\n\nvar getIdsFromUrn = function getIdsFromUrn(urn) {\n  var regExp = /.*:spaces\\/([^/]+)(?:\\/environments\\/([^/]+))?\\/entries\\/([^/]+)$/;\n\n  if (!regExp.test(urn)) {\n    return undefined;\n  }\n\n  var _urn$match = urn.match(regExp),\n      _urn$match2 = _slicedToArray(_urn$match, 4),\n      _ = _urn$match2[0],\n      spaceId = _urn$match2[1],\n      _urn$match2$ = _urn$match2[2],\n      environmentId = _urn$match2$ === undefined ? 'master' : _urn$match2$,\n      entryId = _urn$match2[3];\n\n  return { spaceId: spaceId, environmentId: environmentId, entryId: entryId };\n};\n\n/**\n * getResolvedLink Function\n *\n * @param entityMap\n * @param link\n * @return {undefined}\n */\nvar getResolvedLink = function getResolvedLink(entityMap, link) {\n  var _link$sys = link.sys,\n      type = _link$sys.type,\n      linkType = _link$sys.linkType;\n\n  if (type === 'ResourceLink') {\n    if (!linkType.startsWith('Contentful:')) {\n      return link;\n    }\n\n    var urn = link.sys.urn;\n\n    var _getIdsFromUrn = getIdsFromUrn(urn),\n        spaceId = _getIdsFromUrn.spaceId,\n        environmentId = _getIdsFromUrn.environmentId,\n        _entryId = _getIdsFromUrn.entryId;\n\n    var extractedLinkType = linkType.split(':')[1];\n\n    return lookupInEntityMap(entityMap, {\n      linkType: extractedLinkType,\n      entryId: _entryId,\n      spaceId: spaceId,\n      environmentId: environmentId\n    }) || UNRESOLVED_LINK;\n  }\n\n  var entryId = link.sys.id;\n\n  return lookupInEntityMap(entityMap, { linkType: linkType, entryId: entryId }) || UNRESOLVED_LINK;\n};\n\n/**\n * cleanUpLinks Function\n * - Removes unresolvable links from Arrays and Objects\n *\n * @param {Object[]|Object} input\n */\nvar cleanUpLinks = function cleanUpLinks(input) {\n  if (Array.isArray(input)) {\n    return input.filter(function (val) {\n      return val !== UNRESOLVED_LINK;\n    });\n  }\n  for (var key in input) {\n    if (input[key] === UNRESOLVED_LINK) {\n      delete input[key];\n    }\n  }\n  return input;\n};\n\n/**\n * walkMutate Function\n * @param input\n * @param predicate\n * @param mutator\n * @param removeUnresolved\n * @return {*}\n */\nvar walkMutate = function walkMutate(input, predicate, mutator, removeUnresolved) {\n  if (predicate(input)) {\n    return mutator(input);\n  }\n\n  if (input && (typeof input === 'undefined' ? 'undefined' : _typeof(input)) === 'object') {\n    for (var key in input) {\n      // eslint-disable-next-line no-prototype-builtins\n      if (input.hasOwnProperty(key)) {\n        input[key] = walkMutate(input[key], predicate, mutator, removeUnresolved);\n      }\n    }\n    if (removeUnresolved) {\n      input = cleanUpLinks(input);\n    }\n  }\n  return input;\n};\n\nvar normalizeLink = function normalizeLink(entityMap, link, removeUnresolved) {\n  var resolvedLink = getResolvedLink(entityMap, link);\n  if (resolvedLink === UNRESOLVED_LINK) {\n    return removeUnresolved ? resolvedLink : link;\n  }\n  return resolvedLink;\n};\n\nvar makeEntryObject = function makeEntryObject(item, itemEntryPoints) {\n  if (!Array.isArray(itemEntryPoints)) {\n    return item;\n  }\n\n  var entryPoints = Object.keys(item).filter(function (ownKey) {\n    return itemEntryPoints.indexOf(ownKey) !== -1;\n  });\n\n  return entryPoints.reduce(function (entryObj, entryPoint) {\n    entryObj[entryPoint] = item[entryPoint];\n    return entryObj;\n  }, {});\n};\n\n/**\n * resolveResponse Function\n * Resolves contentful response to normalized form.\n * @param {Object} response Contentful response\n * @param {{removeUnresolved: Boolean, itemEntryPoints: Array<String>}|{}} options\n * @param {Boolean} options.removeUnresolved - Remove unresolved links default:false\n * @param {Array<String>} options.itemEntryPoints - Resolve links only in those item properties\n * @return {Object}\n */\nvar resolveResponse = function resolveResponse(response, options) {\n  options = options || {};\n  if (!response.items) {\n    return [];\n  }\n  var responseClone = copy(response);\n  var allIncludes = Object.keys(responseClone.includes || {}).reduce(function (all, type) {\n    return [].concat(_toConsumableArray(all), _toConsumableArray(response.includes[type]));\n  }, []);\n\n  var allEntries = [].concat(_toConsumableArray(responseClone.items), _toConsumableArray(allIncludes)).filter(function (entity) {\n    return Boolean(entity.sys);\n  });\n\n  var entityMap = new Map(allEntries.reduce(function (acc, entity) {\n    var entries = makeEntityMapKeys(entity.sys).map(function (key) {\n      return [key, entity];\n    });\n    acc.push.apply(acc, _toConsumableArray(entries));\n    return acc;\n  }, []));\n\n  allEntries.forEach(function (item) {\n    var entryObject = makeEntryObject(item, options.itemEntryPoints);\n\n    Object.assign(item, walkMutate(entryObject, function (x) {\n      return isLink(x) || isResourceLink(x);\n    }, function (link) {\n      return normalizeLink(entityMap, link, options.removeUnresolved);\n    }, options.removeUnresolved));\n  });\n\n  return responseClone.items;\n};\n\nexport default resolveResponse;","(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n    typeof define === 'function' && define.amd ? define(factory) :\n    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global[\"fast-copy\"] = factory());\n})(this, (function () { 'use strict';\n\n    var toStringFunction = Function.prototype.toString;\n    var create = Object.create, defineProperty = Object.defineProperty, getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols, getPrototypeOf$1 = Object.getPrototypeOf;\n    var _a = Object.prototype, hasOwnProperty = _a.hasOwnProperty, propertyIsEnumerable = _a.propertyIsEnumerable;\n    var SYMBOL_PROPERTIES = typeof getOwnPropertySymbols === 'function';\n    var WEAK_MAP = typeof WeakMap === 'function';\n    /**\n     * @function createCache\n     *\n     * @description\n     * get a new cache object to prevent circular references\n     *\n     * @returns the new cache object\n     */\n    var createCache = (function () {\n        if (WEAK_MAP) {\n            return function () { return new WeakMap(); };\n        }\n        var Cache = /** @class */ (function () {\n            function Cache() {\n                this._keys = [];\n                this._values = [];\n            }\n            Cache.prototype.has = function (key) {\n                return !!~this._keys.indexOf(key);\n            };\n            Cache.prototype.get = function (key) {\n                return this._values[this._keys.indexOf(key)];\n            };\n            Cache.prototype.set = function (key, value) {\n                this._keys.push(key);\n                this._values.push(value);\n            };\n            return Cache;\n        }());\n        return function () { return new Cache(); };\n    })();\n    /**\n     * @function getCleanClone\n     *\n     * @description\n     * get an empty version of the object with the same prototype it has\n     *\n     * @param object the object to build a clean clone from\n     * @param realm the realm the object resides in\n     * @returns the empty cloned object\n     */\n    var getCleanClone = function (object, realm) {\n        var prototype = object.__proto__ || getPrototypeOf$1(object);\n        if (!prototype) {\n            return create(null);\n        }\n        var Constructor = prototype.constructor;\n        if (Constructor === realm.Object) {\n            return prototype === realm.Object.prototype ? {} : create(prototype);\n        }\n        if (~toStringFunction.call(Constructor).indexOf('[native code]')) {\n            try {\n                return new Constructor();\n            }\n            catch (_a) { }\n        }\n        return create(prototype);\n    };\n    /**\n     * @function getObjectCloneLoose\n     *\n     * @description\n     * get a copy of the object based on loose rules, meaning all enumerable keys\n     * and symbols are copied, but property descriptors are not considered\n     *\n     * @param object the object to clone\n     * @param realm the realm the object resides in\n     * @param handleCopy the function that handles copying the object\n     * @returns the copied object\n     */\n    var getObjectCloneLoose = function (object, realm, handleCopy, cache) {\n        var clone = getCleanClone(object, realm);\n        // set in the cache immediately to be able to reuse the object recursively\n        cache.set(object, clone);\n        for (var key in object) {\n            if (hasOwnProperty.call(object, key)) {\n                clone[key] = handleCopy(object[key], cache);\n            }\n        }\n        if (SYMBOL_PROPERTIES) {\n            var symbols = getOwnPropertySymbols(object);\n            for (var index = 0, length_1 = symbols.length, symbol = void 0; index < length_1; ++index) {\n                symbol = symbols[index];\n                if (propertyIsEnumerable.call(object, symbol)) {\n                    clone[symbol] = handleCopy(object[symbol], cache);\n                }\n            }\n        }\n        return clone;\n    };\n    /**\n     * @function getObjectCloneStrict\n     *\n     * @description\n     * get a copy of the object based on strict rules, meaning all keys and symbols\n     * are copied based on the original property descriptors\n     *\n     * @param object the object to clone\n     * @param realm the realm the object resides in\n     * @param handleCopy the function that handles copying the object\n     * @returns the copied object\n     */\n    var getObjectCloneStrict = function (object, realm, handleCopy, cache) {\n        var clone = getCleanClone(object, realm);\n        // set in the cache immediately to be able to reuse the object recursively\n        cache.set(object, clone);\n        var properties = SYMBOL_PROPERTIES\n            ? getOwnPropertyNames(object).concat(getOwnPropertySymbols(object))\n            : getOwnPropertyNames(object);\n        for (var index = 0, length_2 = properties.length, property = void 0, descriptor = void 0; index < length_2; ++index) {\n            property = properties[index];\n            if (property !== 'callee' && property !== 'caller') {\n                descriptor = getOwnPropertyDescriptor(object, property);\n                if (descriptor) {\n                    // Only clone the value if actually a value, not a getter / setter.\n                    if (!descriptor.get && !descriptor.set) {\n                        descriptor.value = handleCopy(object[property], cache);\n                    }\n                    try {\n                        defineProperty(clone, property, descriptor);\n                    }\n                    catch (error) {\n                        // Tee above can fail on node in edge cases, so fall back to the loose assignment.\n                        clone[property] = descriptor.value;\n                    }\n                }\n                else {\n                    // In extra edge cases where the property descriptor cannot be retrived, fall back to\n                    // the loose assignment.\n                    clone[property] = handleCopy(object[property], cache);\n                }\n            }\n        }\n        return clone;\n    };\n    /**\n     * @function getRegExpFlags\n     *\n     * @description\n     * get the flags to apply to the copied regexp\n     *\n     * @param regExp the regexp to get the flags of\n     * @returns the flags for the regexp\n     */\n    var getRegExpFlags = function (regExp) {\n        var flags = '';\n        if (regExp.global) {\n            flags += 'g';\n        }\n        if (regExp.ignoreCase) {\n            flags += 'i';\n        }\n        if (regExp.multiline) {\n            flags += 'm';\n        }\n        if (regExp.unicode) {\n            flags += 'u';\n        }\n        if (regExp.sticky) {\n            flags += 'y';\n        }\n        return flags;\n    };\n\n    // utils\n    var isArray = Array.isArray;\n    var getPrototypeOf = Object.getPrototypeOf;\n    var GLOBAL_THIS = (function () {\n        if (typeof globalThis !== 'undefined') {\n            return globalThis;\n        }\n        if (typeof self !== 'undefined') {\n            return self;\n        }\n        if (typeof window !== 'undefined') {\n            return window;\n        }\n        if (typeof global !== 'undefined') {\n            return global;\n        }\n        if (console && console.error) {\n            console.error('Unable to locate global object, returning \"this\".');\n        }\n        return this;\n    })();\n    /**\n     * @function copy\n     *\n     * @description\n     * copy an value deeply as much as possible\n     *\n     * If `strict` is applied, then all properties (including non-enumerable ones)\n     * are copied with their original property descriptors on both objects and arrays.\n     *\n     * The value is compared to the global constructors in the `realm` provided,\n     * and the native constructor is always used to ensure that extensions of native\n     * objects (allows in ES2015+) are maintained.\n     *\n     * @param value the value to copy\n     * @param [options] the options for copying with\n     * @param [options.isStrict] should the copy be strict\n     * @param [options.realm] the realm (this) value the value is copied from\n     * @returns the copied value\n     */\n    function copy(value, options) {\n        // manually coalesced instead of default parameters for performance\n        var isStrict = !!(options && options.isStrict);\n        var realm = (options && options.realm) || GLOBAL_THIS;\n        var getObjectClone = isStrict ? getObjectCloneStrict : getObjectCloneLoose;\n        /**\n         * @function handleCopy\n         *\n         * @description\n         * copy the value recursively based on its type\n         *\n         * @param value the value to copy\n         * @returns the copied value\n         */\n        var handleCopy = function (value, cache) {\n            if (!value || typeof value !== 'object') {\n                return value;\n            }\n            if (cache.has(value)) {\n                return cache.get(value);\n            }\n            var prototype = value.__proto__ || getPrototypeOf(value);\n            var Constructor = prototype && prototype.constructor;\n            // plain objects\n            if (!Constructor || Constructor === realm.Object) {\n                return getObjectClone(value, realm, handleCopy, cache);\n            }\n            var clone;\n            // arrays\n            if (isArray(value)) {\n                // if strict, include non-standard properties\n                if (isStrict) {\n                    return getObjectCloneStrict(value, realm, handleCopy, cache);\n                }\n                clone = new Constructor();\n                cache.set(value, clone);\n                for (var index = 0, length_1 = value.length; index < length_1; ++index) {\n                    clone[index] = handleCopy(value[index], cache);\n                }\n                return clone;\n            }\n            // dates\n            if (value instanceof realm.Date) {\n                return new Constructor(value.getTime());\n            }\n            // regexps\n            if (value instanceof realm.RegExp) {\n                clone = new Constructor(value.source, value.flags || getRegExpFlags(value));\n                clone.lastIndex = value.lastIndex;\n                return clone;\n            }\n            // maps\n            if (realm.Map && value instanceof realm.Map) {\n                clone = new Constructor();\n                cache.set(value, clone);\n                value.forEach(function (value, key) {\n                    clone.set(key, handleCopy(value, cache));\n                });\n                return clone;\n            }\n            // sets\n            if (realm.Set && value instanceof realm.Set) {\n                clone = new Constructor();\n                cache.set(value, clone);\n                value.forEach(function (value) {\n                    clone.add(handleCopy(value, cache));\n                });\n                return clone;\n            }\n            // blobs\n            if (realm.Blob && value instanceof realm.Blob) {\n                return value.slice(0, value.size, value.type);\n            }\n            // buffers (node-only)\n            if (realm.Buffer && realm.Buffer.isBuffer(value)) {\n                clone = realm.Buffer.allocUnsafe\n                    ? realm.Buffer.allocUnsafe(value.length)\n                    : new Constructor(value.length);\n                cache.set(value, clone);\n                value.copy(clone);\n                return clone;\n            }\n            // arraybuffers / dataviews\n            if (realm.ArrayBuffer) {\n                // dataviews\n                if (realm.ArrayBuffer.isView(value)) {\n                    clone = new Constructor(value.buffer.slice(0));\n                    cache.set(value, clone);\n                    return clone;\n                }\n                // arraybuffers\n                if (value instanceof realm.ArrayBuffer) {\n                    clone = value.slice(0);\n                    cache.set(value, clone);\n                    return clone;\n                }\n            }\n            // if the value cannot / should not be cloned, don't\n            if (\n            // promise-like\n            typeof value.then === 'function' ||\n                // errors\n                value instanceof Error ||\n                // weakmaps\n                (realm.WeakMap && value instanceof realm.WeakMap) ||\n                // weaksets\n                (realm.WeakSet && value instanceof realm.WeakSet)) {\n                return value;\n            }\n            // assume anything left is a custom constructor\n            return getObjectClone(value, realm, handleCopy, cache);\n        };\n        return handleCopy(value, createCache());\n    }\n    // Adding reference to allow usage in CommonJS libraries compiled using TSC, which\n    // expects there to be a default property on the exported value. See\n    // [#37](https://github.com/planttheidea/fast-copy/issues/37) for details.\n    copy.default = copy;\n    /**\n     * @function strictCopy\n     *\n     * @description\n     * copy the value with `strict` option pre-applied\n     *\n     * @param value the value to copy\n     * @param [options] the options for copying with\n     * @param [options.realm] the realm (this) value the value is copied from\n     * @returns the copied value\n     */\n    copy.strict = function strictCopy(value, options) {\n        return copy(value, {\n            isStrict: true,\n            realm: options ? options.realm : void 0,\n        });\n    };\n\n    return copy;\n\n}));\n//# sourceMappingURL=fast-copy.js.map\n"],"names":["_typeof","Symbol","iterator","obj","constructor","prototype","_slicedToArray","arr","i","Array","isArray","Object","sliceIterator","_arr","_n","_d","_e","undefined","_s","_i","next","done","push","value","length","err","_toConsumableArray","from","arr2","UNRESOLVED_LINK","lookupInEntityMap","entityMap","linkData","entryId","linkType","spaceId","environmentId","get","getIdsFromUrn","urn","regExp","test","_urn$match2","match","_urn$match2$","getResolvedLink","link","_link$sys","sys","type","startsWith","_getIdsFromUrn","_entryId","split","id","cleanUpLinks","input","filter","val","key","walkMutate","predicate","mutator","removeUnresolved","hasOwnProperty","normalizeLink","resolvedLink","__webpack_exports__","Z","response","options","items","responseClone","fast_copy__WEBPACK_IMPORTED_MODULE_0___default","allIncludes","keys","includes","reduce","all","concat","allEntries","entity","Boolean","Map","acc","entries","makeEntityMapKeys","space","environment","map","apply","forEach","item","itemEntryPoints","entryObject","entryPoints","ownKey","indexOf","entryObj","entryPoint","assign","x","isLink","object","factory","toStringFunction","Function","toString","create","defineProperty","getOwnPropertyDescriptor","getOwnPropertyNames","getOwnPropertySymbols","getPrototypeOf$1","getPrototypeOf","_a","propertyIsEnumerable","SYMBOL_PROPERTIES","WEAK_MAP","WeakMap","createCache","Cache","_keys","_values","has","set","getCleanClone","realm","__proto__","Constructor","call","getObjectCloneLoose","handleCopy","cache","clone","symbols","index","length_1","symbol","getObjectCloneStrict","properties","length_2","property","descriptor","error","getRegExpFlags","flags","global","ignoreCase","multiline","unicode","sticky","GLOBAL_THIS","globalThis","self","window","__webpack_require__","g","console","copy","isStrict","getObjectClone","Date","getTime","RegExp","source","lastIndex","Set","add","Blob","slice","size","Buffer","isBuffer","allocUnsafe","ArrayBuffer","isView","buffer","then","Error","WeakSet","default","strict","module","exports"],"sourceRoot":""}