1/******/ (() => { // webpackBootstrap 2/******/ "use strict"; 3/******/ // The require scope 4/******/ var __webpack_require__ = {}; 5/******/ 6/************************************************************************/ 7/******/ /* webpack/runtime/define property getters */ 8/******/ (() => { 9/******/ // define getter functions for harmony exports 10/******/ __webpack_require__.d = (exports, definition) => { 11/******/ for(var key in definition) { 12/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 13/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 14/******/ } 15/******/ } 16/******/ }; 17/******/ })(); 18/******/ 19/******/ /* webpack/runtime/hasOwnProperty shorthand */ 20/******/ (() => { 21/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 22/******/ })(); 23/******/ 24/******/ /* webpack/runtime/make namespace object */ 25/******/ (() => { 26/******/ // define __esModule on exports 27/******/ __webpack_require__.r = (exports) => { 28/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 29/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 30/******/ } 31/******/ Object.defineProperty(exports, '__esModule', { value: true }); 32/******/ }; 33/******/ })(); 34/******/ 35/************************************************************************/ 36var __webpack_exports__ = {}; 37__webpack_require__.r(__webpack_exports__); 38/* harmony export */ __webpack_require__.d(__webpack_exports__, { 39/* harmony export */ autop: () => (/* binding */ autop), 40/* harmony export */ removep: () => (/* binding */ removep) 41/* harmony export */ }); 42/** 43 * The regular expression for an HTML element. 44 */ 45const htmlSplitRegex = (() => { 46 /* eslint-disable no-multi-spaces */ 47 const comments = '!' + 48 // Start of comment, after the <. 49 '(?:' + 50 // Unroll the loop: Consume everything until --> is found. 51 '-(?!->)' + 52 // Dash not followed by end of comment. 53 '[^\\-]*' + 54 // Consume non-dashes. 55 ')*' + 56 // Loop possessively. 57 '(?:-->)?'; // End of comment. If not found, match all input. 58 59 const cdata = '!\\[CDATA\\[' + 60 // Start of comment, after the <. 61 '[^\\]]*' + 62 // Consume non-]. 63 '(?:' + 64 // Unroll the loop: Consume everything until ]]> is found. 65 '](?!]>)' + 66 // One ] not followed by end of comment. 67 '[^\\]]*' + 68 // Consume non-]. 69 ')*?' + 70 // Loop possessively. 71 '(?:]]>)?'; // End of comment. If not found, match all input. 72 73 const escaped = '(?=' + 74 // Is the element escaped? 75 '!--' + '|' + '!\\[CDATA\\[' + ')' + '((?=!-)' + 76 // If yes, which type? 77 comments + '|' + cdata + ')'; 78 const regex = '(' + 79 // Capture the entire match. 80 '<' + 81 // Find start of element. 82 '(' + 83 // Conditional expression follows. 84 escaped + 85 // Find end of escaped element. 86 '|' + 87 // ... else ... 88 '[^>]*>?' + 89 // Find end of normal element. 90 ')' + ')'; 91 return new RegExp(regex); 92 /* eslint-enable no-multi-spaces */ 93})(); 94 95/** 96 * Separate HTML elements and comments from the text. 97 * 98 * @param input The text which has to be formatted. 99 * 100 * @return The formatted text. 101 */ 102function htmlSplit(input) { 103 const parts = []; 104 let workingInput = input; 105 let match; 106 while (match = workingInput.match(htmlSplitRegex)) { 107 // The `match` result, when invoked on a RegExp with the `g` flag (`/foo/g`) will not include `index`. 108 // If the `g` flag is omitted, `index` is included. 109 // `htmlSplitRegex` does not have the `g` flag so we can assert it will have an index number. 110 // Assert `match.index` is a number. 111 const index = match.index; 112 parts.push(workingInput.slice(0, index)); 113 parts.push(match[0]); 114 workingInput = workingInput.slice(index + match[0].length); 115 } 116 if (workingInput.length) { 117 parts.push(workingInput); 118 } 119 return parts; 120} 121 122/** 123 * Replace characters or phrases within HTML elements only. 124 * 125 * @param haystack The text which has to be formatted. 126 * @param replacePairs In the form {from: 'to', â¦}. 127 * 128 * @return The formatted text. 129 */ 130function replaceInHtmlTags(haystack, replacePairs) { 131 // Find all elements. 132 const textArr = htmlSplit(haystack); 133 let changed = false;
134 135 // Extract all needles. 136 const needles = Object.keys(replacePairs); 137 138 // Loop through delimiters (elements) only. 139 for (let i = 1; i < textArr.length; i += 2) { 140 for (let j = 0; j < needles.length; j++) { 141 const needle = needles[j]; 142 if (-1 !== textArr[i].indexOf(needle)) { 143 textArr[i] = textArr[i].replace(new RegExp(needle, 'g'), replacePairs[needle]); 144 changed = true; 145 // After one strtr() break out of the foreach loop and look at next element. 146 break; 147 } 148 } 149 } 150 if (changed) { 151 haystack = textArr.join(''); 152 } 153 return haystack; 154} 155 156/** 157 * Replaces double line-breaks with paragraph elements. 158 * 159 * A group of regex replaces used to identify text formatted with newlines and 160 * replace double line-breaks with HTML paragraph tags. The remaining line- 161 * breaks after conversion become `<br />` tags, unless br is set to 'false'. 162 * 163 * @param text The text which has to be formatted. 164 * @param br Optional. If set, will convert all remaining line- 165 * breaks after paragraphing. Default true. 166 * 167 * @example 168 *```js 169 * import { autop } from '@wordpress/autop'; 170 * autop( 'my text' ); // "<p>my text</p>" 171 * ``` 172 * 173 * @return Text which has been converted into paragraph tags. 174 */ 175function autop(text, br = true) { 176 const preTags = []; 177 if (text.trim() === '') { 178 return ''; 179 } 180 181 // Just to make things a little easier, pad the end. 182 text = text + '\n'; 183 184 /* 185 * Pre tags shouldn't be touched by autop. 186 * Replace pre tags with placeholders and bring them back after autop. 187 */ 188 if (text.indexOf('<pre') !== -1) { 189 const textParts = text.split('</pre>'); 190 const lastText = textParts.pop(); 191 text = ''; 192 for (let i = 0; i < textParts.length; i++) { 193 const textPart = textParts[i]; 194 const start = textPart.indexOf('<pre'); 195 196 // Malformed html? 197 if (start === -1) { 198 text += textPart; 199 continue; 200 } 201 const name = '<pre wp-pre-tag-' + i + '></pre>'; 202 preTags.push([name, textPart.substr(start) + '</pre>']); 203 text += textPart.substr(0, start) + name; 204 } 205 text += lastText; 206 } 207 // Change multiple <br>s into two line breaks, which will turn into paragraphs. 208 text = text.replace(/<br\s*\/?>\s*<br\s*\/?>/g, '\n\n'); 209 const allBlocks = '(?:table|thead|tfoot|caption|col|colgroup|tbody|tr|td|th|div|dl|dd|dt|ul|ol|li|pre|form|map|area|blockquote|address|math|style|p|h[1-6]|hr|fieldset|legend|section|article|aside|hgroup|header|footer|nav|figure|figcaption|details|menu|summary)'; 210 211 // Add a double line break above block-level opening tags. 212 text = text.replace(new RegExp('(<' + allBlocks + '[\\s/>])', 'g'), '\n\n$1'); 213 214 // Add a double line break below block-level closing tags. 215 text = text.replace(new RegExp('(</' + allBlocks + '>)', 'g'), '$1\n\n'); 216 217 // Standardize newline characters to "\n". 218 text = text.replace(/\r\n|\r/g, '\n'); 219 220 // Find newlines in all elements and add placeholders. 221 text = replaceInHtmlTags(text, { 222 '\n': ' <!-- wpnl --> ' 223 }); 224 225 // Collapse line breaks before and after <option> elements so they don't get autop'd. 226 if (text.indexOf('<option') !== -1) { 227 text = text.replace(/\s*<option/g, '<option'); 228 text = text.replace(/<\/option>\s*/g, '</option>'); 229 } 230 231 /* 232 * Collapse line breaks inside <object> elements, before <param> and <embed> elements 233 * so they don't get autop'd. 234 */ 235 if (text.indexOf('</object>') !== -1) { 236 text = text.replace(/(<object[^>]*>)\s*/g, '$1'); 237 text = text.replace(/\s*<\/object>/g, '</object>'); 238 text = text.replace(/\s*(<\/?(?:param|embed)[^>]*>)\s*/g, '$1'); 239 } 240 241 /* 242 * Collapse line breaks inside <audio> and <video> elements, 243 * before and after <source> and <track> elements. 244 */ 245 if (text.indexOf('<source') !== -1 || text.indexOf('<track') !== -1) { 246 text = text.replace(/([<\[](?:audio|video)[^>\]]*[>\]])\s*/g, '$1'); 247 text = text.replace(/\s*([<\[]\/(?:audio|video)[>\]])/g, '$1'); 248 text = text.replace(/\s*(<(?:source|track)[^>]*>)\s*/g, '$1'); 249 } 250 251 // Collapse line breaks before and after <figcaption> elements. 252 if (text.indexOf('<figcaption') !== -1) { 253 text = text.replace(/\s*(<figcaption[^>]*>)/, '$1'); 254 text = text.replace(/<\/figcaption>
254\s*/, '</figcaption>'); 255 } 256 257 // Remove more than two contiguous line breaks. 258 text = text.replace(/\n\n+/g, '\n\n'); 259 260 // Split up the contents into an array of strings, separated by double line breaks. 261 const texts = text.split(/\n\s*\n/).filter(Boolean); 262 263 // Reset text prior to rebuilding. 264 text = ''; 265 266 // Rebuild the content as a string, wrapping every bit with a <p>. 267 texts.forEach(textPiece => { 268 text += '<p>' + textPiece.replace(/^\n*|\n*$/g, '') + '</p>\n'; 269 }); 270 271 // Under certain strange conditions it could create a P of entirely whitespace. 272 text = text.replace(/<p>\s*<\/p>/g, ''); 273 274 // Add a closing <p> inside <div>, <address>, or <form> tag if missing. 275 text = text.replace(/<p>([^<]+)<\/(div|address|form)>/g, '<p>$1</p></$2>'); 276 277 // If an opening or closing block element tag is wrapped in a <p>, unwrap it. 278 text = text.replace(new RegExp('<p>\\s*(</?' + allBlocks + '[^>]*>)\\s*</p>', 'g'), '$1'); 279 280 // In some cases <li> may get wrapped in <p>, fix them. 281 text = text.replace(/<p>(<li.+?)<\/p>/g, '$1'); 282 283 // If a <blockquote> is wrapped with a <p>, move it inside the <blockquote>. 284 text = text.replace(/<p><blockquote([^>]*)>/gi, '<blockquote$1><p>'); 285 text = text.replace(/<\/blockquote><\/p>/g, '</p></blockquote>'); 286 287 // If an opening or closing block element tag is preceded by an opening <p> tag, remove it. 288 text = text.replace(new RegExp('<p>\\s*(</?' + allBlocks + '[^>]*>)', 'g'), '$1'); 289 290 // If an opening or closing block element tag is followed by a closing <p> tag, remove it. 291 text = text.replace(new RegExp('(</?' + allBlocks + '[^>]*>)\\s*</p>', 'g'), '$1'); 292 293 // Optionally insert line breaks. 294 if (br) { 295 // Replace newlines that shouldn't be touched with a placeholder. 296 text = text.replace(/<(script|style).*?<\/\\1>/g, match => match[0].replace(/\n/g, '<WPPreserveNewline />')); 297 298 // Normalize <br> 299 text = text.replace(/<br>|<br\/>/g, '<br />'); 300 301 // Replace any new line characters that aren't preceded by a <br /> with a <br />. 302 text = text.replace(/(<br \/>)?\s*\n/g, (a, b) => b ? a : '<br />\n'); 303 304 // Replace newline placeholders with newlines. 305 text = text.replace(/<WPPreserveNewline \/>/g, '\n'); 306 } 307 308 // If a <br /> tag is after an opening or closing block tag, remove it. 309 text = text.replace(new RegExp('(</?' + allBlocks + '[^>]*>)\\s*<br />', 'g'), '$1'); 310 311 // If a <br /> tag is before a subset of opening or closing block tags, remove it. 312 text = text.replace(/<br \/>(\s*<\/?(?:p|li|div|dl|dd|dt|th|pre|td|ul|ol)[^>]*>)/g, '$1'); 313 text = text.replace(/\n<\/p>$/g, '</p>'); 314 315 // Replace placeholder <pre> tags with their original content. 316 preTags.forEach(preTag => { 317 const [name, original] = preTag; 318 text = text.replace(name, original); 319 }); 320 321 // Restore newlines in all elements. 322 if (-1 !== text.indexOf('<!-- wpnl -->')) { 323 text = text.replace(/\s?<!-- wpnl -->\s?/g, '\n'); 324 } 325 return text; 326} 327 328/** 329 * Replaces `<p>` tags with two line breaks. "Opposite" of autop(). 330 * 331 * Replaces `<p>` tags with two line breaks except where the `<p>` has attributes. 332 * Unifies whitespace. Indents `<li>`, `<dt>` and `<dd>` for better readability. 333 * 334 * @param html The content from the editor. 335 * 336 * @example 337 * ```js 338 * import { removep } from '@wordpress/autop'; 339 * removep( '<p>my text</p>' ); // "my text" 340 * ``` 341 * 342 * @return The content with stripped paragraph tags. 343 */ 344function removep(html) { 345 const blocklist = 'blockquote|ul|ol|li|dl|dt|dd|table|thead|tbody|tfoot|tr|th|td|h[1-6]|fieldset|figure'; 346 const blocklist1 = blocklist + '|div|p'; 347 const blocklist2 = blocklist + '|pre'; 348 const preserve = []; 349 let preserveLinebreaks = false; 350 let preserveBr = false; 351 if (!html) { 352 return ''; 353 } 354 355 // Protect script and style tags. 356 if (html.indexOf('<script') !== -1 || html.indexOf('<style') !== -1) { 357 html = html.replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/g, match => { 358 preserve.push(match); 359 return '<wp-preserve>'; 360 }); 361 } 362 363 // Protect pre tags. 364 if (html.indexOf('<pre') !== -1) { 365 preserveLinebreaks = true; 366 html = html.replace(/<pre[^>]*>[\s\S]+?<\/pre>/g, a => { 367 a = a.replace(/<br ?\/?>(\r\n|\n)?/g, '<wp-line-break>'); 368 a = a.replace(/<\/?p( [^>]*)?>(\r\n|\n)?/g, '<wp-line-break>'); 369 return a.replace(/\r?\n/g, '<wp-line-break>'); 370 }); 371 } 372 373 // Remove line breaks but keep <br> tags inside image captions. 374 if (html.indexOf('[caption') !== -1) { 375 preserveBr = true; 376 html = html.replace(/\[caption[\s\S]+?\[\/caption\]/g, a => { 377 return a.replace(/<br([^>]*)>/g, '<wp-temp-br$1>').replace(/[\r\n\t]+/, ''); 378 }); 379 } 380 381 // Normalize white space characters before and after block tags. 382 html = html.replace(new RegExp('\\s*</(' + blocklist1 + ')>\\s*', 'g'), '</$1>\n'); 383 html = html.replace(new RegExp('\\s*<((?:' + blocklist1 + ')(?: [^>]*)?)>', 'g'), '\n<$1>'); 384 385 // Mark </p> if it has any attributes. 386 html = html.replace(/(<p [^>]+>[\s\S]*?)<\/p>/g, '$1</p#>'); 387 388 // Preserve the first <p> inside a <div>. 389 html = html.replace(/<div( [^>]*)?>\s*<p>/gi, '<div$1>\n\n'); 390 391 // Remove paragraph tags. 392 html = html.replace(/\s*<p>/gi, ''); 393 html = html.replace(/\s*<\/p>\s*/gi, '\n\n'); 394 395 // Normalize white space chars and remove multiple line breaks. 396 html = html.replace(/\n[\s\u00a0]+\n/g, '\n\n'); 397 398 // Replace <br> tags with line breaks. 399 html = html.replace(/(\s*)<br ?\/?>
399\s*/gi, (_, space) => { 400 if (space && space.indexOf('\n') !== -1) { 401 return '\n\n'; 402 } 403 return '\n'; 404 }); 405 406 // Fix line breaks around <div>. 407 html = html.replace(/\s*<div/g, '\n<div'); 408 html = html.replace(/<\/div>\s*/g, '</div>\n'); 409 410 // Fix line breaks around caption shortcodes. 411 html = html.replace(/\s*\[caption([^\[]+)\[\/caption\]\s*/gi, '\n\n[caption$1[/caption]\n\n'); 412 html = html.replace(/caption\]\n\n+\[caption/g, 'caption]\n\n[caption'); 413 414 // Pad block elements tags with a line break. 415 html = html.replace(new RegExp('\\s*<((?:' + blocklist2 + ')(?: [^>]*)?)\\s*>', 'g'), '\n<$1>'); 416 html = html.replace(new RegExp('\\s*</(' + blocklist2 + ')>\\s*', 'g'), '</$1>\n'); 417 418 // Indent <li>, <dt> and <dd> tags. 419 html = html.replace(/<((li|dt|dd)[^>]*)>/g, ' \t<$1>'); 420 421 // Fix line breaks around <select> and <option>. 422 if (html.indexOf('<option') !== -1) { 423 html = html.replace(/\s*<option/g, '\n<option'); 424 html = html.replace(/\s*<\/select>/g, '\n</select>'); 425 } 426 427 // Pad <hr> with two line breaks. 428 if (html.indexOf('<hr') !== -1) { 429 html = html.replace(/\s*<hr( [^>]*)?>\s*/g, '\n\n<hr$1>\n\n'); 430 } 431 432 // Remove line breaks in <object> tags. 433 if (html.indexOf('<object') !== -1) { 434 html = html.replace(/<object[\s\S]+?<\/object>/g, a => { 435 return a.replace(/[\r\n]+/g, ''); 436 }); 437 } 438 439 // Unmark special paragraph closing tags. 440 html = html.replace(/<\/p#>/g, '</p>\n'); 441 442 // Pad remaining <p> tags whit a line break. 443 html = html.replace(/\s*(<p [^>]+>[\s\S]*?<\/p>)/g, '\n$1'); 444 445 // Trim. 446 html = html.replace(/^\s+/, ''); 447 html = html.replace(/[\s\u00a0]+$/, ''); 448 if (preserveLinebreaks) { 449 html = html.replace(/<wp-line-break>/g, '\n'); 450 } 451 if (preserveBr) { 452 html = html.replace(/<wp-temp-br([^>]*)>/g, '<br$1>'); 453 } 454 455 // Restore preserved tags. 456 if (preserve.length) { 457 html = html.replace(/<wp-preserve>/g, () => { 458 return preserve.shift(); 459 }); 460 } 461 return html; 462} 463 464(window.wp = window.wp || {}).autop = __webpack_exports__; 465/******/ })() 466;
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.