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