diff -r c7c34916027a -r 177826044cd9 wp/wp-includes/js/dist/block-serialization-default-parser.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wp/wp-includes/js/dist/block-serialization-default-parser.js Mon Oct 14 18:28:13 2019 +0200 @@ -0,0 +1,550 @@ +this["wp"] = this["wp"] || {}; this["wp"]["blockSerializationDefaultParser"] = +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 258); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ 258: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parse", function() { return parse; }); +/* harmony import */ var _babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(28); + +var document; +var offset; +var output; +var stack; +/** + * Matches block comment delimiters + * + * While most of this pattern is straightforward the attribute parsing + * incorporates a tricks to make sure we don't choke on specific input + * + * - since JavaScript has no possessive quantifier or atomic grouping + * we are emulating it with a trick + * + * we want a possessive quantifier or atomic group to prevent backtracking + * on the `}`s should we fail to match the remainder of the pattern + * + * we can emulate this with a positive lookahead and back reference + * (a++)*c === ((?=(a+))\1)*c + * + * let's examine an example: + * - /(a+)*c/.test('aaaaaaaaaaaaad') fails after over 49,000 steps + * - /(a++)*c/.test('aaaaaaaaaaaaad') fails after 85 steps + * - /(?>a+)*c/.test('aaaaaaaaaaaaad') fails after 126 steps + * + * this is because the possessive `++` and the atomic group `(?>)` + * tell the engine that all those `a`s belong together as a single group + * and so it won't split it up when stepping backwards to try and match + * + * if we use /((?=(a+))\1)*c/ then we get the same behavior as the atomic group + * or possessive and prevent the backtracking because the `a+` is matched but + * not captured. thus, we find the long string of `a`s and remember it, then + * reference it as a whole unit inside our pattern + * + * @cite http://instanceof.me/post/52245507631/regex-emulate-atomic-grouping-with-lookahead + * @cite http://blog.stevenlevithan.com/archives/mimic-atomic-groups + * @cite https://javascript.info/regexp-infinite-backtracking-problem + * + * once browsers reliably support atomic grouping or possessive + * quantifiers natively we should remove this trick and simplify + * + * @type RegExp + * + * @since 3.8.0 + * @since 4.6.1 added optimization to prevent backtracking on attribute parsing + */ + +var tokenizer = /)[^])*)\5|[^]*?)}\s+)?(\/)?-->/g; + +function Block(blockName, attrs, innerBlocks, innerHTML, innerContent) { + return { + blockName: blockName, + attrs: attrs, + innerBlocks: innerBlocks, + innerHTML: innerHTML, + innerContent: innerContent + }; +} + +function Freeform(innerHTML) { + return Block(null, {}, [], innerHTML, [innerHTML]); +} + +function Frame(block, tokenStart, tokenLength, prevOffset, leadingHtmlStart) { + return { + block: block, + tokenStart: tokenStart, + tokenLength: tokenLength, + prevOffset: prevOffset || tokenStart + tokenLength, + leadingHtmlStart: leadingHtmlStart + }; +} +/** + * Parser function, that converts input HTML into a block based structure. + * + * @param {string} doc The HTML document to parse. + * + * @example + * Input post: + * ```html + * + *
+ *
+ *

Left

+ *
+ * + * + * + *
+ *

Middle

+ *
+ * + * + * + *
+ *
+ * + * ``` + * + * Parsing code: + * ```js + * import { parse } from '@wordpress/block-serialization-default-parser'; + * + * parse( post ) === [ + * { + * blockName: "core/columns", + * attrs: { + * columns: 3 + * }, + * innerBlocks: [ + * { + * blockName: "core/column", + * attrs: null, + * innerBlocks: [ + * { + * blockName: "core/paragraph", + * attrs: null, + * innerBlocks: [], + * innerHTML: "\n

Left

\n" + * } + * ], + * innerHTML: '\n
\n' + * }, + * { + * blockName: "core/column", + * attrs: null, + * innerBlocks: [ + * { + * blockName: "core/paragraph", + * attrs: null, + * innerBlocks: [], + * innerHTML: "\n

Middle

\n" + * } + * ], + * innerHTML: '\n
\n' + * }, + * { + * blockName: "core/column", + * attrs: null, + * innerBlocks: [], + * innerHTML: '\n
\n' + * } + * ], + * innerHTML: '\n
\n\n\n\n
\n' + * } + * ]; + * ``` + * @return {Array} A block-based representation of the input HTML. + */ + + +var parse = function parse(doc) { + document = doc; + offset = 0; + output = []; + stack = []; + tokenizer.lastIndex = 0; + + do {// twiddle our thumbs + } while (proceed()); + + return output; +}; + +function proceed() { + var next = nextToken(); + + var _next = Object(_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(next, 5), + tokenType = _next[0], + blockName = _next[1], + attrs = _next[2], + startOffset = _next[3], + tokenLength = _next[4]; + + var stackDepth = stack.length; // we may have some HTML soup before the next block + + var leadingHtmlStart = startOffset > offset ? offset : null; + + switch (tokenType) { + case 'no-more-tokens': + // if not in a block then flush output + if (0 === stackDepth) { + addFreeform(); + return false; + } // Otherwise we have a problem + // This is an error + // we have options + // - treat it all as freeform text + // - assume an implicit closer (easiest when not nesting) + // for the easy case we'll assume an implicit closer + + + if (1 === stackDepth) { + addBlockFromStack(); + return false; + } // for the nested case where it's more difficult we'll + // have to assume that multiple closers are missing + // and so we'll collapse the whole stack piecewise + + + while (0 < stack.length) { + addBlockFromStack(); + } + + return false; + + case 'void-block': + // easy case is if we stumbled upon a void block + // in the top-level of the document + if (0 === stackDepth) { + if (null !== leadingHtmlStart) { + output.push(Freeform(document.substr(leadingHtmlStart, startOffset - leadingHtmlStart))); + } + + output.push(Block(blockName, attrs, [], '', [])); + offset = startOffset + tokenLength; + return true; + } // otherwise we found an inner block + + + addInnerBlock(Block(blockName, attrs, [], '', []), startOffset, tokenLength); + offset = startOffset + tokenLength; + return true; + + case 'block-opener': + // track all newly-opened blocks on the stack + stack.push(Frame(Block(blockName, attrs, [], '', []), startOffset, tokenLength, startOffset + tokenLength, leadingHtmlStart)); + offset = startOffset + tokenLength; + return true; + + case 'block-closer': + // if we're missing an opener we're in trouble + // This is an error + if (0 === stackDepth) { + // we have options + // - assume an implicit opener + // - assume _this_ is the opener + // - give up and close out the document + addFreeform(); + return false; + } // if we're not nesting then this is easy - close the block + + + if (1 === stackDepth) { + addBlockFromStack(startOffset); + offset = startOffset + tokenLength; + return true; + } // otherwise we're nested and we have to close out the current + // block and add it as a innerBlock to the parent + + + var stackTop = stack.pop(); + var html = document.substr(stackTop.prevOffset, startOffset - stackTop.prevOffset); + stackTop.block.innerHTML += html; + stackTop.block.innerContent.push(html); + stackTop.prevOffset = startOffset + tokenLength; + addInnerBlock(stackTop.block, stackTop.tokenStart, stackTop.tokenLength, startOffset + tokenLength); + offset = startOffset + tokenLength; + return true; + + default: + // This is an error + addFreeform(); + return false; + } +} +/** + * Parse JSON if valid, otherwise return null + * + * Note that JSON coming from the block comment + * delimiters is constrained to be an object + * and cannot be things like `true` or `null` + * + * @param {string} input JSON input string to parse + * @return {Object|null} parsed JSON if valid + */ + + +function parseJSON(input) { + try { + return JSON.parse(input); + } catch (e) { + return null; + } +} + +function nextToken() { + // aye the magic + // we're using a single RegExp to tokenize the block comment delimiters + // we're also using a trick here because the only difference between a + // block opener and a block closer is the leading `/` before `wp:` (and + // a closer has no attributes). we can trap them both and process the + // match back in Javascript to see which one it was. + var matches = tokenizer.exec(document); // we have no more tokens + + if (null === matches) { + return ['no-more-tokens']; + } + + var startedAt = matches.index; + + var _matches = Object(_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(matches, 7), + match = _matches[0], + closerMatch = _matches[1], + namespaceMatch = _matches[2], + nameMatch = _matches[3], + attrsMatch = _matches[4], + + /* internal/unused */ + voidMatch = _matches[6]; + + var length = match.length; + var isCloser = !!closerMatch; + var isVoid = !!voidMatch; + var namespace = namespaceMatch || 'core/'; + var name = namespace + nameMatch; + var hasAttrs = !!attrsMatch; + var attrs = hasAttrs ? parseJSON(attrsMatch) : {}; // This state isn't allowed + // This is an error + + if (isCloser && (isVoid || hasAttrs)) {// we can ignore them since they don't hurt anything + // we may warn against this at some point or reject it + } + + if (isVoid) { + return ['void-block', name, attrs, startedAt, length]; + } + + if (isCloser) { + return ['block-closer', name, null, startedAt, length]; + } + + return ['block-opener', name, attrs, startedAt, length]; +} + +function addFreeform(rawLength) { + var length = rawLength ? rawLength : document.length - offset; + + if (0 === length) { + return; + } + + output.push(Freeform(document.substr(offset, length))); +} + +function addInnerBlock(block, tokenStart, tokenLength, lastOffset) { + var parent = stack[stack.length - 1]; + parent.block.innerBlocks.push(block); + var html = document.substr(parent.prevOffset, tokenStart - parent.prevOffset); + + if (html) { + parent.block.innerHTML += html; + parent.block.innerContent.push(html); + } + + parent.block.innerContent.push(null); + parent.prevOffset = lastOffset ? lastOffset : tokenStart + tokenLength; +} + +function addBlockFromStack(endOffset) { + var _stack$pop = stack.pop(), + block = _stack$pop.block, + leadingHtmlStart = _stack$pop.leadingHtmlStart, + prevOffset = _stack$pop.prevOffset, + tokenStart = _stack$pop.tokenStart; + + var html = endOffset ? document.substr(prevOffset, endOffset - prevOffset) : document.substr(prevOffset); + + if (html) { + block.innerHTML += html; + block.innerContent.push(html); + } + + if (null !== leadingHtmlStart) { + output.push(Freeform(document.substr(leadingHtmlStart, tokenStart - leadingHtmlStart))); + } + + output.push(block); +} + + +/***/ }), + +/***/ 28: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js +var arrayWithHoles = __webpack_require__(37); + +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js +function _iterableToArrayLimit(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"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; +} +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js +var nonIterableRest = __webpack_require__(38); + +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _slicedToArray; }); + + + +function _slicedToArray(arr, i) { + return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(nonIterableRest["a" /* default */])(); +} + +/***/ }), + +/***/ 37: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; }); +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +/***/ }), + +/***/ 38: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; }); +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); +} + +/***/ }) + +/******/ }); \ No newline at end of file