{"version":3,"file":"js/244-9d5e28ceec4f56ec7d2b.js","mappings":"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","sources":["webpack://bare-core/./node_modules/@contentful/rich-text-html-renderer/dist/rich-text-html-renderer.es5.js","webpack://bare-core/./node_modules/@contentful/rich-text-types/dist/index.js","webpack://bare-core/./node_modules/escape-html/index.js","webpack://bare-core/./node_modules/is-plain-obj/index.js"],"sourcesContent":["'use strict';\n\nvar richTextTypes = require('@contentful/rich-text-types');\nvar escape = require('escape-html');\n\n/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol */\r\n\r\n\r\nvar __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\n\r\ntypeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\n\nvar _a, _b;\nvar attributeValue = function (value) { return \"\\\"\".concat(value.replace(/\"/g, '&quot;'), \"\\\"\"); };\nvar defaultNodeRenderers = (_a = {},\n    _a[richTextTypes.BLOCKS.PARAGRAPH] = function (node, next) { return \"<p>\".concat(next(node.content), \"</p>\"); },\n    _a[richTextTypes.BLOCKS.HEADING_1] = function (node, next) { return \"<h1>\".concat(next(node.content), \"</h1>\"); },\n    _a[richTextTypes.BLOCKS.HEADING_2] = function (node, next) { return \"<h2>\".concat(next(node.content), \"</h2>\"); },\n    _a[richTextTypes.BLOCKS.HEADING_3] = function (node, next) { return \"<h3>\".concat(next(node.content), \"</h3>\"); },\n    _a[richTextTypes.BLOCKS.HEADING_4] = function (node, next) { return \"<h4>\".concat(next(node.content), \"</h4>\"); },\n    _a[richTextTypes.BLOCKS.HEADING_5] = function (node, next) { return \"<h5>\".concat(next(node.content), \"</h5>\"); },\n    _a[richTextTypes.BLOCKS.HEADING_6] = function (node, next) { return \"<h6>\".concat(next(node.content), \"</h6>\"); },\n    _a[richTextTypes.BLOCKS.EMBEDDED_ENTRY] = function (node, next) { return \"<div>\".concat(next(node.content), \"</div>\"); },\n    _a[richTextTypes.BLOCKS.EMBEDDED_RESOURCE] = function (node, next) { return \"<div>\".concat(next(node.content), \"</div>\"); },\n    _a[richTextTypes.BLOCKS.UL_LIST] = function (node, next) { return \"<ul>\".concat(next(node.content), \"</ul>\"); },\n    _a[richTextTypes.BLOCKS.OL_LIST] = function (node, next) { return \"<ol>\".concat(next(node.content), \"</ol>\"); },\n    _a[richTextTypes.BLOCKS.LIST_ITEM] = function (node, next) { return \"<li>\".concat(next(node.content), \"</li>\"); },\n    _a[richTextTypes.BLOCKS.QUOTE] = function (node, next) { return \"<blockquote>\".concat(next(node.content), \"</blockquote>\"); },\n    _a[richTextTypes.BLOCKS.HR] = function () { return '<hr/>'; },\n    _a[richTextTypes.BLOCKS.TABLE] = function (node, next) { return \"<table>\".concat(next(node.content), \"</table>\"); },\n    _a[richTextTypes.BLOCKS.TABLE_ROW] = function (node, next) { return \"<tr>\".concat(next(node.content), \"</tr>\"); },\n    _a[richTextTypes.BLOCKS.TABLE_HEADER_CELL] = function (node, next) { return \"<th>\".concat(next(node.content), \"</th>\"); },\n    _a[richTextTypes.BLOCKS.TABLE_CELL] = function (node, next) { return \"<td>\".concat(next(node.content), \"</td>\"); },\n    _a[richTextTypes.INLINES.ASSET_HYPERLINK] = function (node) { return defaultInline(richTextTypes.INLINES.ASSET_HYPERLINK, node); },\n    _a[richTextTypes.INLINES.ENTRY_HYPERLINK] = function (node) { return defaultInline(richTextTypes.INLINES.ENTRY_HYPERLINK, node); },\n    _a[richTextTypes.INLINES.RESOURCE_HYPERLINK] = function (node) {\n        return defaultInlineResource(richTextTypes.INLINES.RESOURCE_HYPERLINK, node);\n    },\n    _a[richTextTypes.INLINES.EMBEDDED_ENTRY] = function (node) { return defaultInline(richTextTypes.INLINES.EMBEDDED_ENTRY, node); },\n    _a[richTextTypes.INLINES.EMBEDDED_RESOURCE] = function (node) {\n        return defaultInlineResource(richTextTypes.INLINES.EMBEDDED_RESOURCE, node);\n    },\n    _a[richTextTypes.INLINES.HYPERLINK] = function (node, next) {\n        var href = typeof node.data.uri === 'string' ? node.data.uri : '';\n        return \"<a href=\".concat(attributeValue(href), \">\").concat(next(node.content), \"</a>\");\n    },\n    _a);\nvar defaultMarkRenderers = (_b = {},\n    _b[richTextTypes.MARKS.BOLD] = function (text) { return \"<b>\".concat(text, \"</b>\"); },\n    _b[richTextTypes.MARKS.ITALIC] = function (text) { return \"<i>\".concat(text, \"</i>\"); },\n    _b[richTextTypes.MARKS.UNDERLINE] = function (text) { return \"<u>\".concat(text, \"</u>\"); },\n    _b[richTextTypes.MARKS.CODE] = function (text) { return \"<code>\".concat(text, \"</code>\"); },\n    _b[richTextTypes.MARKS.SUPERSCRIPT] = function (text) { return \"<sup>\".concat(text, \"</sup>\"); },\n    _b[richTextTypes.MARKS.SUBSCRIPT] = function (text) { return \"<sub>\".concat(text, \"</sub>\"); },\n    _b[richTextTypes.MARKS.STRIKETHROUGH] = function (text) { return \"<s>\".concat(text, \"</s>\"); },\n    _b);\nvar defaultInline = function (type, node) {\n    return \"<span>type: \".concat(escape(type), \" id: \").concat(escape(node.data.target.sys.id), \"</span>\");\n};\nvar defaultInlineResource = function (type, node) {\n    return \"<span>type: \".concat(escape(type), \" urn: \").concat(escape(node.data.target.sys.urn), \"</span>\");\n};\n/**\n * Serialize a Contentful Rich Text `document` to an html string.\n */\nfunction documentToHtmlString(richTextDocument, options) {\n    if (options === void 0) { options = {}; }\n    if (!richTextDocument || !richTextDocument.content) {\n        return '';\n    }\n    return nodeListToHtmlString(richTextDocument.content, {\n        renderNode: __assign(__assign({}, defaultNodeRenderers), options.renderNode),\n        renderMark: __assign(__assign({}, defaultMarkRenderers), options.renderMark),\n        preserveWhitespace: options.preserveWhitespace,\n    });\n}\nfunction nodeListToHtmlString(nodes, _a) {\n    var renderNode = _a.renderNode, renderMark = _a.renderMark, preserveWhitespace = _a.preserveWhitespace;\n    return nodes\n        .map(function (node) { return nodeToHtmlString(node, { renderNode: renderNode, renderMark: renderMark, preserveWhitespace: preserveWhitespace }); })\n        .join('');\n}\nfunction nodeToHtmlString(node, _a) {\n    var renderNode = _a.renderNode, renderMark = _a.renderMark, preserveWhitespace = _a.preserveWhitespace;\n    if (richTextTypes.helpers.isText(node)) {\n        var nodeValue = escape(node.value);\n        // If preserveWhitespace is true, handle line breaks and spaces.\n        if (preserveWhitespace) {\n            nodeValue = nodeValue\n                .replace(/\\n/g, '<br/>')\n                .replace(/ {2,}/g, function (match) { return '&nbsp;'.repeat(match.length); });\n        }\n        if (node.marks.length > 0) {\n            return node.marks.reduce(function (value, mark) {\n                if (!renderMark[mark.type]) {\n                    return value;\n                }\n                return renderMark[mark.type](value);\n            }, nodeValue);\n        }\n        return nodeValue;\n    }\n    else {\n        var nextNode = function (nodes) {\n            return nodeListToHtmlString(nodes, { renderMark: renderMark, renderNode: renderNode, preserveWhitespace: preserveWhitespace });\n        };\n        if (!node.nodeType || !renderNode[node.nodeType]) {\n            // TODO: Figure what to return when passed an unrecognized node.\n            return '';\n        }\n        return renderNode[node.nodeType](node, nextNode);\n    }\n}\n\nexports.documentToHtmlString = documentToHtmlString;\n//# sourceMappingURL=rich-text-html-renderer.es5.js.map\n","'use strict';\n\nvar isPlainObject = require('is-plain-obj');\n\n/**\n * Map of all Contentful block types. Blocks contain inline or block nodes.\n */\nexports.BLOCKS = void 0;\n(function (BLOCKS) {\n    BLOCKS[\"DOCUMENT\"] = \"document\";\n    BLOCKS[\"PARAGRAPH\"] = \"paragraph\";\n    BLOCKS[\"HEADING_1\"] = \"heading-1\";\n    BLOCKS[\"HEADING_2\"] = \"heading-2\";\n    BLOCKS[\"HEADING_3\"] = \"heading-3\";\n    BLOCKS[\"HEADING_4\"] = \"heading-4\";\n    BLOCKS[\"HEADING_5\"] = \"heading-5\";\n    BLOCKS[\"HEADING_6\"] = \"heading-6\";\n    BLOCKS[\"OL_LIST\"] = \"ordered-list\";\n    BLOCKS[\"UL_LIST\"] = \"unordered-list\";\n    BLOCKS[\"LIST_ITEM\"] = \"list-item\";\n    BLOCKS[\"HR\"] = \"hr\";\n    BLOCKS[\"QUOTE\"] = \"blockquote\";\n    BLOCKS[\"EMBEDDED_ENTRY\"] = \"embedded-entry-block\";\n    BLOCKS[\"EMBEDDED_ASSET\"] = \"embedded-asset-block\";\n    BLOCKS[\"EMBEDDED_RESOURCE\"] = \"embedded-resource-block\";\n    BLOCKS[\"TABLE\"] = \"table\";\n    BLOCKS[\"TABLE_ROW\"] = \"table-row\";\n    BLOCKS[\"TABLE_CELL\"] = \"table-cell\";\n    BLOCKS[\"TABLE_HEADER_CELL\"] = \"table-header-cell\";\n})(exports.BLOCKS || (exports.BLOCKS = {}));\n\n/**\n * Map of all Contentful inline types. Inline contain inline or text nodes.\n *\n * @note This should be kept in alphabetical order since the\n * [validation package](https://github.com/contentful/content-stack/tree/master/packages/validation)\n *  relies on the values being in a predictable order.\n */\nexports.INLINES = void 0;\n(function (INLINES) {\n    INLINES[\"ASSET_HYPERLINK\"] = \"asset-hyperlink\";\n    INLINES[\"EMBEDDED_ENTRY\"] = \"embedded-entry-inline\";\n    INLINES[\"EMBEDDED_RESOURCE\"] = \"embedded-resource-inline\";\n    INLINES[\"ENTRY_HYPERLINK\"] = \"entry-hyperlink\";\n    INLINES[\"HYPERLINK\"] = \"hyperlink\";\n    INLINES[\"RESOURCE_HYPERLINK\"] = \"resource-hyperlink\";\n})(exports.INLINES || (exports.INLINES = {}));\n\n/**\n * Map of all Contentful marks.\n */\nexports.MARKS = void 0;\n(function (MARKS) {\n    MARKS[\"BOLD\"] = \"bold\";\n    MARKS[\"ITALIC\"] = \"italic\";\n    MARKS[\"UNDERLINE\"] = \"underline\";\n    MARKS[\"CODE\"] = \"code\";\n    MARKS[\"SUPERSCRIPT\"] = \"superscript\";\n    MARKS[\"SUBSCRIPT\"] = \"subscript\";\n    MARKS[\"STRIKETHROUGH\"] = \"strikethrough\";\n})(exports.MARKS || (exports.MARKS = {}));\n\n/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nfunction __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nfunction __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\ntypeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\n\nvar _a$1;\n/**\n * Array of all top level block types.\n * Only these block types can be the direct children of the document.\n */\nvar TOP_LEVEL_BLOCKS = [\n    exports.BLOCKS.PARAGRAPH,\n    exports.BLOCKS.HEADING_1,\n    exports.BLOCKS.HEADING_2,\n    exports.BLOCKS.HEADING_3,\n    exports.BLOCKS.HEADING_4,\n    exports.BLOCKS.HEADING_5,\n    exports.BLOCKS.HEADING_6,\n    exports.BLOCKS.OL_LIST,\n    exports.BLOCKS.UL_LIST,\n    exports.BLOCKS.HR,\n    exports.BLOCKS.QUOTE,\n    exports.BLOCKS.EMBEDDED_ENTRY,\n    exports.BLOCKS.EMBEDDED_ASSET,\n    exports.BLOCKS.EMBEDDED_RESOURCE,\n    exports.BLOCKS.TABLE,\n];\n/**\n * Array of all allowed block types inside list items\n */\nvar LIST_ITEM_BLOCKS = [\n    exports.BLOCKS.PARAGRAPH,\n    exports.BLOCKS.HEADING_1,\n    exports.BLOCKS.HEADING_2,\n    exports.BLOCKS.HEADING_3,\n    exports.BLOCKS.HEADING_4,\n    exports.BLOCKS.HEADING_5,\n    exports.BLOCKS.HEADING_6,\n    exports.BLOCKS.OL_LIST,\n    exports.BLOCKS.UL_LIST,\n    exports.BLOCKS.HR,\n    exports.BLOCKS.QUOTE,\n    exports.BLOCKS.EMBEDDED_ENTRY,\n    exports.BLOCKS.EMBEDDED_ASSET,\n    exports.BLOCKS.EMBEDDED_RESOURCE,\n];\nvar TABLE_BLOCKS = [\n    exports.BLOCKS.TABLE,\n    exports.BLOCKS.TABLE_ROW,\n    exports.BLOCKS.TABLE_CELL,\n    exports.BLOCKS.TABLE_HEADER_CELL,\n];\n/**\n * Array of all void block types\n */\nvar VOID_BLOCKS = [\n    exports.BLOCKS.HR,\n    exports.BLOCKS.EMBEDDED_ENTRY,\n    exports.BLOCKS.EMBEDDED_ASSET,\n    exports.BLOCKS.EMBEDDED_RESOURCE,\n];\n/**\n * Dictionary of all container block types, and the set block types they accept as children.\n *\n * Note: This does not include `[BLOCKS.DOCUMENT]: TOP_LEVEL_BLOCKS`\n */\nvar CONTAINERS = (_a$1 = {},\n    _a$1[exports.BLOCKS.OL_LIST] = [exports.BLOCKS.LIST_ITEM],\n    _a$1[exports.BLOCKS.UL_LIST] = [exports.BLOCKS.LIST_ITEM],\n    _a$1[exports.BLOCKS.LIST_ITEM] = LIST_ITEM_BLOCKS,\n    _a$1[exports.BLOCKS.QUOTE] = [exports.BLOCKS.PARAGRAPH],\n    _a$1[exports.BLOCKS.TABLE] = [exports.BLOCKS.TABLE_ROW],\n    _a$1[exports.BLOCKS.TABLE_ROW] = [exports.BLOCKS.TABLE_CELL, exports.BLOCKS.TABLE_HEADER_CELL],\n    _a$1[exports.BLOCKS.TABLE_CELL] = [exports.BLOCKS.PARAGRAPH, exports.BLOCKS.UL_LIST, exports.BLOCKS.OL_LIST],\n    _a$1[exports.BLOCKS.TABLE_HEADER_CELL] = [exports.BLOCKS.PARAGRAPH],\n    _a$1);\n/**\n * Array of all heading levels\n */\nvar HEADINGS = [\n    exports.BLOCKS.HEADING_1,\n    exports.BLOCKS.HEADING_2,\n    exports.BLOCKS.HEADING_3,\n    exports.BLOCKS.HEADING_4,\n    exports.BLOCKS.HEADING_5,\n    exports.BLOCKS.HEADING_6,\n];\n/**\n * Array of all block types that may contain text and inline nodes.\n */\nvar TEXT_CONTAINERS = __spreadArray([exports.BLOCKS.PARAGRAPH], HEADINGS, true);\n/**\n * Node types before `tables` release.\n */\nvar V1_NODE_TYPES = [\n    exports.BLOCKS.DOCUMENT,\n    exports.BLOCKS.PARAGRAPH,\n    exports.BLOCKS.HEADING_1,\n    exports.BLOCKS.HEADING_2,\n    exports.BLOCKS.HEADING_3,\n    exports.BLOCKS.HEADING_4,\n    exports.BLOCKS.HEADING_5,\n    exports.BLOCKS.HEADING_6,\n    exports.BLOCKS.OL_LIST,\n    exports.BLOCKS.UL_LIST,\n    exports.BLOCKS.LIST_ITEM,\n    exports.BLOCKS.HR,\n    exports.BLOCKS.QUOTE,\n    exports.BLOCKS.EMBEDDED_ENTRY,\n    exports.BLOCKS.EMBEDDED_ASSET,\n    exports.INLINES.HYPERLINK,\n    exports.INLINES.ENTRY_HYPERLINK,\n    exports.INLINES.ASSET_HYPERLINK,\n    exports.INLINES.EMBEDDED_ENTRY,\n    'text',\n];\n/**\n * Marks before `superscript` & `subscript` release.\n */\nvar V1_MARKS = [exports.MARKS.BOLD, exports.MARKS.CODE, exports.MARKS.ITALIC, exports.MARKS.UNDERLINE];\n\n/**\n * A rich text document considered to be empty.\n * Any other document structure than this is not considered empty.\n */\nvar EMPTY_DOCUMENT = {\n    nodeType: exports.BLOCKS.DOCUMENT,\n    data: {},\n    content: [\n        {\n            nodeType: exports.BLOCKS.PARAGRAPH,\n            data: {},\n            content: [\n                {\n                    nodeType: 'text',\n                    value: '',\n                    marks: [],\n                    data: {},\n                },\n            ],\n        },\n    ],\n};\n\n/**\n * Tiny replacement for Object.values(object).includes(key) to\n * avoid including CoreJS polyfills\n */\nfunction hasValue(obj, value) {\n    for (var _i = 0, _a = Object.keys(obj); _i < _a.length; _i++) {\n        var key = _a[_i];\n        if (value === obj[key]) {\n            return true;\n        }\n    }\n    return false;\n}\n/**\n * Checks if the node is an instance of Inline.\n */\nfunction isInline(node) {\n    return hasValue(exports.INLINES, node.nodeType);\n}\n/**\n * Checks if the node is an instance of Block.\n */\nfunction isBlock(node) {\n    return hasValue(exports.BLOCKS, node.nodeType);\n}\n/**\n * Checks if the node is an instance of Text.\n */\nfunction isText(node) {\n    return node.nodeType === 'text';\n}\n\nvar helpers = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  isBlock: isBlock,\n  isInline: isInline,\n  isText: isText\n});\n\nvar typeMismatchError = function (_a) {\n    var path = _a.path, property = _a.property, typeName = _a.typeName, value = _a.value;\n    return {\n        details: \"The type of \\\"\".concat(property, \"\\\" is incorrect, expected type: \").concat(typeName),\n        name: 'type',\n        path: path.toArray(),\n        type: typeName,\n        value: value,\n    };\n};\nvar minSizeError = function (_a) {\n    var min = _a.min, value = _a.value, path = _a.path;\n    return {\n        name: 'size',\n        min: min,\n        path: path.toArray(),\n        details: \"Size must be at least \".concat(min),\n        value: value,\n    };\n};\nvar maxSizeError = function (_a) {\n    var max = _a.max, value = _a.value, path = _a.path;\n    return {\n        name: 'size',\n        max: max,\n        path: path.toArray(),\n        details: \"Size must be at most \".concat(max),\n        value: value,\n    };\n};\nvar enumError = function (_a) {\n    var expected = _a.expected, value = _a.value, path = _a.path;\n    return {\n        details: \"Value must be one of expected values\",\n        name: 'in',\n        expected: __spreadArray([], expected, true).sort(),\n        path: path.toArray(),\n        value: value,\n    };\n};\nvar unknownPropertyError = function (_a) {\n    var property = _a.property, path = _a.path;\n    return {\n        details: \"The property \\\"\".concat(property, \"\\\" is not expected\"),\n        name: 'unexpected',\n        path: path.toArray(),\n    };\n};\nvar requiredPropertyError = function (_a) {\n    var property = _a.property, path = _a.path;\n    return {\n        details: \"The property \\\"\".concat(property, \"\\\" is required here\"),\n        name: 'required',\n        path: path.toArray(),\n    };\n};\n\nvar ObjectAssertion = /** @class */ (function () {\n    function ObjectAssertion(obj, path) {\n        var _this = this;\n        this.obj = obj;\n        this.path = path;\n        this._errors = [];\n        this.catch = function () {\n            var _a;\n            var errors = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                errors[_i] = arguments[_i];\n            }\n            (_a = _this._errors).push.apply(_a, errors);\n        };\n        /**\n         * Asserts the key exists in the object. You probably shouldn't call this\n         * function directly. Instead, use `$.object`, `$.number`, `$.string`, etc.\n         */\n        this.exists = function (key) {\n            if (key in _this.obj) {\n                return true;\n            }\n            _this.catch(requiredPropertyError({\n                property: key,\n                path: _this.path.of(key),\n            }));\n            return false;\n        };\n        /**\n         * Asserts the key exists in the object and its value is a plain object. if\n         * no key is provided, it asserts the object itself.\n         */\n        this.object = function (key) {\n            var _a;\n            var value = key ? _this.obj[key] : _this.obj;\n            if (key) {\n                if (!_this.exists(key)) {\n                    return false;\n                }\n            }\n            if (isPlainObject(value)) {\n                return true;\n            }\n            var path = key ? _this.path.of(key) : _this.path;\n            var property = (_a = key !== null && key !== void 0 ? key : _this.path.last()) !== null && _a !== void 0 ? _a : 'value';\n            _this.catch(typeMismatchError({\n                typeName: 'Object',\n                property: property,\n                path: path,\n                value: value,\n            }));\n            return false;\n        };\n        /**\n         * Asserts the key exists in the object and its value is a string.\n         */\n        this.string = function (key) {\n            var value = _this.obj[key];\n            if (key && !_this.exists(key)) {\n                return false;\n            }\n            if (typeof value === 'string') {\n                return true;\n            }\n            _this.catch(typeMismatchError({\n                typeName: 'String',\n                property: key,\n                path: _this.path.of(key),\n                value: value,\n            }));\n            return false;\n        };\n        /**\n         * Asserts the key exists in the object and its value is a number.\n         */\n        this.number = function (key, optional) {\n            var value = _this.obj[key];\n            if (optional && !(key in _this.obj)) {\n                return true;\n            }\n            if (!_this.exists(key)) {\n                return false;\n            }\n            if (typeof value === 'number' && !Number.isNaN(value)) {\n                return true;\n            }\n            _this.catch(typeMismatchError({\n                typeName: 'Number',\n                property: key,\n                path: _this.path.of(key),\n                value: value,\n            }));\n            return false;\n        };\n        /**\n         * Asserts the key exists in the object and its value is an array. You don't\n         * need to manually call this function before `$.each` or `$.maxLength`.\n         */\n        this.array = function (key) {\n            var value = _this.obj[key];\n            if (key && !_this.exists(key)) {\n                return false;\n            }\n            if (Array.isArray(value)) {\n                return true;\n            }\n            _this.catch(typeMismatchError({\n                typeName: 'Array',\n                property: key,\n                path: _this.path.of(key),\n                value: value,\n            }));\n            return false;\n        };\n        /**\n         * Asserts the value of the key is one of the expected values.\n         */\n        this.enum = function (key, expected) {\n            var value = _this.obj[key];\n            if (typeof value === 'string' && expected.includes(value)) {\n                return true;\n            }\n            _this.catch(enumError({\n                expected: expected,\n                value: value,\n                path: _this.path.of(key),\n            }));\n            return false;\n        };\n        /**\n         * Asserts the array value of the object key is empty. If the value isn't an\n         * array, the function captures a type error and returns false.\n         */\n        this.empty = function (key) {\n            if (!_this.array(key)) {\n                return false;\n            }\n            var value = _this.obj[key];\n            if (value.length === 0) {\n                return true;\n            }\n            _this.catch(maxSizeError({\n                max: 0,\n                value: value,\n                path: _this.path.of(key),\n            }));\n            return false;\n        };\n        /**\n         * Asserts the length of the value of the object key is at least `min`. If the\n         * value isn't an array, the function captures a type error and returns false.\n         */\n        this.minLength = function (key, min) {\n            if (!_this.array(key)) {\n                return false;\n            }\n            var value = _this.obj[key];\n            if (value.length >= min) {\n                return true;\n            }\n            _this.catch(minSizeError({\n                min: min,\n                value: value,\n                path: _this.path.of(key),\n            }));\n            return false;\n        };\n        /**\n         * Asserts the object has no additional properties other than the ones\n         * specified\n         */\n        this.noAdditionalProperties = function (properties) {\n            var unknowns = Object.keys(_this.obj)\n                .sort()\n                .filter(function (key) { return !properties.includes(key); });\n            unknowns.forEach(function (property) {\n                return _this.catch(unknownPropertyError({\n                    property: property,\n                    path: _this.path.of(property),\n                }));\n            });\n            return unknowns.length === 0;\n        };\n        /**\n         * Iterates over the value of the key and assert each item. If the value isn't\n         * an array, the function captures a type error and safely exits.\n         *\n         * To maintain compatibility with previous implementation, we stop early if we\n         * find any errors.\n         */\n        this.each = function (key, assert) {\n            if (!_this.array(key)) {\n                return;\n            }\n            var value = _this.obj[key];\n            var foundErrors = false;\n            value.forEach(function (item, index) {\n                if (foundErrors) {\n                    return;\n                }\n                var errors = assert(item, _this.path.of(key).of(index));\n                if (errors.length > 0) {\n                    foundErrors = true;\n                }\n                _this.catch.apply(_this, errors);\n            });\n        };\n    }\n    Object.defineProperty(ObjectAssertion.prototype, \"errors\", {\n        get: function () {\n            var _this = this;\n            var serializeError = function (error) {\n                return JSON.stringify({\n                    details: error.details,\n                    path: error.path,\n                });\n            };\n            return this._errors.filter(function (error, index) {\n                return _this._errors.findIndex(function (step) { return serializeError(error) === serializeError(step); }) === index;\n            });\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return ObjectAssertion;\n}());\n\nvar VOID_CONTENT = [];\nvar NodeAssertion = /** @class */ (function () {\n    function NodeAssertion(contentRule, validateData) {\n        this.contentRule = contentRule;\n        this.validateData = validateData;\n    }\n    NodeAssertion.prototype.assert = function (node, path) {\n        var _a, _b;\n        var $ = new ObjectAssertion(node, path);\n        if (!$.object()) {\n            return $.errors;\n        }\n        $.noAdditionalProperties(['nodeType', 'data', 'content']);\n        var _c = Array.isArray(this.contentRule)\n            ? {\n                nodeTypes: this.contentRule,\n            }\n            : this.contentRule(node, path), nodeTypes = _c.nodeTypes, _d = _c.min, min = _d === void 0 ? 0 : _d;\n        if (nodeTypes.length === 0 && min > 0) {\n            throw new Error(\"Invalid content rule. Cannot have enforce a 'min' of \".concat(min, \" with no nodeTypes\"));\n        }\n        $.minLength('content', min);\n        // Is void\n        if (nodeTypes.length === 0) {\n            $.empty('content');\n        }\n        // Ensure content nodes have valid nodeTypes without validating the full\n        // shape which is something that's only done later if the current node is\n        // valid.\n        else {\n            $.each('content', function (item, path) {\n                var item$ = new ObjectAssertion(item, path);\n                if (!item$.object()) {\n                    return item$.errors;\n                }\n                item$.enum('nodeType', nodeTypes);\n                return item$.errors;\n            });\n        }\n        if ($.object('data')) {\n            var dataErrors = (_b = (_a = this.validateData) === null || _a === void 0 ? void 0 : _a.call(this, node.data, path.of('data'))) !== null && _b !== void 0 ? _b : [];\n            $.catch.apply($, dataErrors);\n        }\n        return $.errors;\n    };\n    return NodeAssertion;\n}());\nvar EntityLinkAssertion = /** @class */ (function (_super) {\n    __extends(EntityLinkAssertion, _super);\n    function EntityLinkAssertion(linkType, contentNodeTypes) {\n        var _this = _super.call(this, contentNodeTypes, function (data, path) { return _this.assertLink(data, path); }) || this;\n        _this.linkType = linkType;\n        _this.assertLink = function (data, path) {\n            var $ = new ObjectAssertion(data, path);\n            if ($.object('target')) {\n                var sys$ = new ObjectAssertion(data.target.sys, path.of('target').of('sys'));\n                if (sys$.object()) {\n                    sys$.enum('type', [_this.type]);\n                    sys$.enum('linkType', [_this.linkType]);\n                    if (_this.type === 'Link') {\n                        sys$.string('id');\n                        sys$.noAdditionalProperties(['type', 'linkType', 'id']);\n                    }\n                    else if (_this.type === 'ResourceLink') {\n                        sys$.string('urn');\n                        sys$.noAdditionalProperties(['type', 'linkType', 'urn']);\n                    }\n                }\n                $.catch.apply($, sys$.errors);\n            }\n            $.noAdditionalProperties(['target']);\n            return $.errors;\n        };\n        _this.type = _this.linkType.startsWith('Contentful:') ? 'ResourceLink' : 'Link';\n        return _this;\n    }\n    return EntityLinkAssertion;\n}(NodeAssertion));\nvar HyperLinkAssertion = /** @class */ (function (_super) {\n    __extends(HyperLinkAssertion, _super);\n    function HyperLinkAssertion() {\n        var _this = _super.call(this, ['text'], function (data, path) { return _this.assertLink(data, path); }) || this;\n        _this.assertLink = function (data, path) {\n            var $ = new ObjectAssertion(data, path);\n            $.string('uri');\n            $.noAdditionalProperties(['uri']);\n            return $.errors;\n        };\n        return _this;\n    }\n    return HyperLinkAssertion;\n}(NodeAssertion));\nvar assert = function (contentRule, validateData) {\n    return new NodeAssertion(contentRule, validateData);\n};\nvar assertLink = function (linkType, contentRule) {\n    return new EntityLinkAssertion(linkType, contentRule);\n};\n\nvar Path = /** @class */ (function () {\n    function Path(path) {\n        if (path === void 0) { path = []; }\n        var _this = this;\n        this.path = path;\n        this.of = function (element) {\n            return new Path(__spreadArray(__spreadArray([], _this.path, true), [element], false));\n        };\n        this.isRoot = function () {\n            return _this.path.length === 0;\n        };\n        this.last = function () {\n            return _this.path[_this.path.length - 1];\n        };\n        this.toArray = function () {\n            return _this.path;\n        };\n    }\n    return Path;\n}());\n\nfunction assertText(text, path) {\n    var $ = new ObjectAssertion(text, path);\n    if (!$.object()) {\n        return $.errors;\n    }\n    $.noAdditionalProperties(['nodeType', 'data', 'value', 'marks']);\n    $.object('data');\n    $.each('marks', function (mark, path) {\n        var mark$ = new ObjectAssertion(mark, path);\n        if (!mark$.object()) {\n            return mark$.errors;\n        }\n        // For historical reasons, we don't explicitly check for supported marks\n        // e.g. bold, italic ..etc. This makes it possible for a customer to add\n        // custom marks\n        mark$.string('type');\n        return mark$.errors;\n    });\n    $.string('value');\n    return $.errors;\n}\n\nvar _a;\nvar assertInlineOrText = assert(__spreadArray(__spreadArray([], Object.values(exports.INLINES), true), ['text'], false).sort());\nvar assertList = assert([exports.BLOCKS.LIST_ITEM]);\nvar assertVoidEntryLink = assertLink('Entry', VOID_CONTENT);\nvar assertTableCell = assert(function () { return ({\n    nodeTypes: [exports.BLOCKS.PARAGRAPH],\n    min: 1,\n}); }, function (data, path) {\n    var $ = new ObjectAssertion(data, path);\n    $.noAdditionalProperties(['colspan', 'rowspan']);\n    $.number('colspan', true);\n    $.number('rowspan', true);\n    return $.errors;\n});\nvar nodeValidator = (_a = {},\n    _a[exports.BLOCKS.DOCUMENT] = assert(TOP_LEVEL_BLOCKS),\n    _a[exports.BLOCKS.PARAGRAPH] = assertInlineOrText,\n    _a[exports.BLOCKS.HEADING_1] = assertInlineOrText,\n    _a[exports.BLOCKS.HEADING_2] = assertInlineOrText,\n    _a[exports.BLOCKS.HEADING_3] = assertInlineOrText,\n    _a[exports.BLOCKS.HEADING_4] = assertInlineOrText,\n    _a[exports.BLOCKS.HEADING_5] = assertInlineOrText,\n    _a[exports.BLOCKS.HEADING_6] = assertInlineOrText,\n    _a[exports.BLOCKS.QUOTE] = assert(CONTAINERS[exports.BLOCKS.QUOTE]),\n    _a[exports.BLOCKS.EMBEDDED_ENTRY] = assertVoidEntryLink,\n    _a[exports.BLOCKS.EMBEDDED_ASSET] = assertLink('Asset', VOID_CONTENT),\n    _a[exports.BLOCKS.EMBEDDED_RESOURCE] = assertLink('Contentful:Entry', VOID_CONTENT),\n    _a[exports.BLOCKS.HR] = assert(VOID_CONTENT),\n    _a[exports.BLOCKS.OL_LIST] = assertList,\n    _a[exports.BLOCKS.UL_LIST] = assertList,\n    _a[exports.BLOCKS.LIST_ITEM] = assert(__spreadArray([], LIST_ITEM_BLOCKS, true).sort()),\n    _a[exports.BLOCKS.TABLE] = assert(function () { return ({\n        nodeTypes: [exports.BLOCKS.TABLE_ROW],\n        min: 1,\n    }); }),\n    _a[exports.BLOCKS.TABLE_ROW] = assert(function () { return ({\n        nodeTypes: [exports.BLOCKS.TABLE_CELL, exports.BLOCKS.TABLE_HEADER_CELL],\n        min: 1,\n    }); }),\n    _a[exports.BLOCKS.TABLE_CELL] = assertTableCell,\n    _a[exports.BLOCKS.TABLE_HEADER_CELL] = assertTableCell,\n    _a[exports.INLINES.HYPERLINK] = new HyperLinkAssertion(),\n    _a[exports.INLINES.EMBEDDED_ENTRY] = assertVoidEntryLink,\n    _a[exports.INLINES.EMBEDDED_RESOURCE] = assertLink('Contentful:Entry', VOID_CONTENT),\n    _a[exports.INLINES.ENTRY_HYPERLINK] = assertLink('Entry', ['text']),\n    _a[exports.INLINES.ASSET_HYPERLINK] = assertLink('Asset', ['text']),\n    _a[exports.INLINES.RESOURCE_HYPERLINK] = assertLink('Contentful:Entry', ['text']),\n    _a);\nfunction validateNode(node, path) {\n    if (node.nodeType === 'text') {\n        return assertText(node, path);\n    }\n    var errors = nodeValidator[node.nodeType].assert(node, path);\n    if (errors.length > 0) {\n        return errors;\n    }\n    var $ = new ObjectAssertion(node, path);\n    $.each('content', function (item, path) {\n        // We already know those are valid nodes thanks to the assertion done in\n        // the NodeAssertion class\n        return validateNode(item, path);\n    });\n    return $.errors;\n}\nvar validateRichTextDocument = function (document) {\n    var path = new Path();\n    var $ = new ObjectAssertion(document, path);\n    if ($.object()) {\n        $.enum('nodeType', [exports.BLOCKS.DOCUMENT]);\n    }\n    if ($.errors.length > 0) {\n        return $.errors;\n    }\n    return validateNode(document, path);\n};\n\nexports.CONTAINERS = CONTAINERS;\nexports.EMPTY_DOCUMENT = EMPTY_DOCUMENT;\nexports.HEADINGS = HEADINGS;\nexports.LIST_ITEM_BLOCKS = LIST_ITEM_BLOCKS;\nexports.TABLE_BLOCKS = TABLE_BLOCKS;\nexports.TEXT_CONTAINERS = TEXT_CONTAINERS;\nexports.TOP_LEVEL_BLOCKS = TOP_LEVEL_BLOCKS;\nexports.V1_MARKS = V1_MARKS;\nexports.V1_NODE_TYPES = V1_NODE_TYPES;\nexports.VOID_BLOCKS = VOID_BLOCKS;\nexports.helpers = helpers;\nexports.validateRichTextDocument = validateRichTextDocument;\n//# sourceMappingURL=index.js.map\n","/*!\n * escape-html\n * Copyright(c) 2012-2013 TJ Holowaychuk\n * Copyright(c) 2015 Andreas Lubbe\n * Copyright(c) 2015 Tiancheng \"Timothy\" Gu\n * MIT Licensed\n */\n\n'use strict';\n\n/**\n * Module variables.\n * @private\n */\n\nvar matchHtmlRegExp = /[\"'&<>]/;\n\n/**\n * Module exports.\n * @public\n */\n\nmodule.exports = escapeHtml;\n\n/**\n * Escape special characters in the given string of html.\n *\n * @param  {string} string The string to escape for inserting into HTML\n * @return {string}\n * @public\n */\n\nfunction escapeHtml(string) {\n  var str = '' + string;\n  var match = matchHtmlRegExp.exec(str);\n\n  if (!match) {\n    return str;\n  }\n\n  var escape;\n  var html = '';\n  var index = 0;\n  var lastIndex = 0;\n\n  for (index = match.index; index < str.length; index++) {\n    switch (str.charCodeAt(index)) {\n      case 34: // \"\n        escape = '&quot;';\n        break;\n      case 38: // &\n        escape = '&amp;';\n        break;\n      case 39: // '\n        escape = '&#39;';\n        break;\n      case 60: // <\n        escape = '&lt;';\n        break;\n      case 62: // >\n        escape = '&gt;';\n        break;\n      default:\n        continue;\n    }\n\n    if (lastIndex !== index) {\n      html += str.substring(lastIndex, index);\n    }\n\n    lastIndex = index + 1;\n    html += escape;\n  }\n\n  return lastIndex !== index\n    ? html + str.substring(lastIndex, index)\n    : html;\n}\n","'use strict';\n\nmodule.exports = value => {\n\tif (Object.prototype.toString.call(value) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn prototype === null || prototype === Object.prototype;\n};\n"],"names":["_a","_b","richTextTypes","escape","__assign","Object","assign","t","s","i","n","arguments","length","p","prototype","hasOwnProperty","call","apply","this","SuppressedError","defaultNodeRenderers","BLOCKS","PARAGRAPH","node","next","concat","content","HEADING_1","HEADING_2","HEADING_3","HEADING_4","HEADING_5","HEADING_6","EMBEDDED_ENTRY","EMBEDDED_RESOURCE","UL_LIST","OL_LIST","LIST_ITEM","QUOTE","HR","TABLE","TABLE_ROW","TABLE_HEADER_CELL","TABLE_CELL","INLINES","ASSET_HYPERLINK","defaultInline","ENTRY_HYPERLINK","RESOURCE_HYPERLINK","defaultInlineResource","HYPERLINK","value","href","data","uri","replace","defaultMarkRenderers","MARKS","BOLD","text","ITALIC","UNDERLINE","CODE","SUPERSCRIPT","SUBSCRIPT","STRIKETHROUGH","type","target","sys","id","urn","nodeListToHtmlString","nodes","renderNode","renderMark","preserveWhitespace","map","helpers","isText","nodeValue","match","repeat","marks","reduce","mark","nextNode","nodeType","nodeToHtmlString","join","exports","richTextDocument","options","isPlainObject","_a$1","extendStatics","d","b","setPrototypeOf","__proto__","Array","__extends","TypeError","String","__","constructor","create","__spreadArray","to","from","pack","ar","l","slice","TOP_LEVEL_BLOCKS","EMBEDDED_ASSET","LIST_ITEM_BLOCKS","TABLE_BLOCKS","VOID_BLOCKS","CONTAINERS","HEADINGS","TEXT_CONTAINERS","V1_NODE_TYPES","DOCUMENT","V1_MARKS","EMPTY_DOCUMENT","hasValue","obj","_i","keys","freeze","isBlock","isInline","typeMismatchError","path","property","typeName","details","name","toArray","ObjectAssertion","_this","_errors","catch","errors","push","exists","key","requiredPropertyError","of","object","last","string","number","optional","Number","isNaN","array","isArray","enum","expected","includes","sort","enumError","empty","max","maxSizeError","minLength","min","minSizeError","noAdditionalProperties","properties","unknowns","filter","forEach","unknownPropertyError","each","assert","foundErrors","item","index","defineProperty","get","serializeError","error","JSON","stringify","findIndex","step","enumerable","configurable","VOID_CONTENT","NodeAssertion","contentRule","validateData","$","_c","nodeTypes","_d","Error","item$","dataErrors","EntityLinkAssertion","_super","linkType","contentNodeTypes","assertLink","sys$","startsWith","HyperLinkAssertion","Path","element","isRoot","assertInlineOrText","values","assertList","assertVoidEntryLink","assertTableCell","nodeValidator","validateNode","mark$","assertText","validateRichTextDocument","document","matchHtmlRegExp","module","str","exec","html","lastIndex","charCodeAt","substring","toString","getPrototypeOf"],"sourceRoot":""}