You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
585 lines
18 KiB
585 lines
18 KiB
this["wp"] = this["wp"] || {}; this["wp"]["shortcode"] = |
|
/******/ (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 = 297); |
|
/******/ }) |
|
/************************************************************************/ |
|
/******/ ({ |
|
|
|
/***/ 2: |
|
/***/ (function(module, exports) { |
|
|
|
(function() { module.exports = this["lodash"]; }()); |
|
|
|
/***/ }), |
|
|
|
/***/ 297: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
__webpack_require__.r(__webpack_exports__); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "next", function() { return next; }); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "replace", function() { return replace; }); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "string", function() { return string; }); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "regexp", function() { return regexp; }); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "attrs", function() { return attrs; }); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromMatch", function() { return fromMatch; }); |
|
/* harmony import */ var lodash__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2); |
|
/* harmony import */ var lodash__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(lodash__WEBPACK_IMPORTED_MODULE_0__); |
|
/* harmony import */ var memize__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(41); |
|
/* harmony import */ var memize__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(memize__WEBPACK_IMPORTED_MODULE_1__); |
|
/** |
|
* Internal dependencies |
|
*/ |
|
|
|
|
|
/** |
|
* Shortcode attributes object. |
|
* |
|
* @typedef {Object} WPShortcodeAttrs |
|
* |
|
* @property {Object} named Object with named attributes. |
|
* @property {Array} numeric Array with numeric attributes. |
|
*/ |
|
|
|
/** |
|
* Shortcode object. |
|
* |
|
* @typedef {Object} WPShortcode |
|
* |
|
* @property {string} tag Shortcode tag. |
|
* @property {WPShortcodeAttrs} attrs Shortcode attributes. |
|
* @property {string} content Shortcode content. |
|
* @property {string} type Shortcode type: `self-closing`, |
|
* `closed`, or `single`. |
|
*/ |
|
|
|
/** |
|
* @typedef {Object} WPShortcodeMatch |
|
* |
|
* @property {number} index Index the shortcode is found at. |
|
* @property {string} content Matched content. |
|
* @property {WPShortcode} shortcode Shortcode instance of the match. |
|
*/ |
|
|
|
/** |
|
* Find the next matching shortcode. |
|
* |
|
* @param {string} tag Shortcode tag. |
|
* @param {string} text Text to search. |
|
* @param {number} index Index to start search from. |
|
* |
|
* @return {?WPShortcodeMatch} Matched information. |
|
*/ |
|
|
|
function next(tag, text) { |
|
var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; |
|
var re = regexp(tag); |
|
re.lastIndex = index; |
|
var match = re.exec(text); |
|
|
|
if (!match) { |
|
return; |
|
} // If we matched an escaped shortcode, try again. |
|
|
|
|
|
if ('[' === match[1] && ']' === match[7]) { |
|
return next(tag, text, re.lastIndex); |
|
} |
|
|
|
var result = { |
|
index: match.index, |
|
content: match[0], |
|
shortcode: fromMatch(match) |
|
}; // If we matched a leading `[`, strip it from the match and increment the |
|
// index accordingly. |
|
|
|
if (match[1]) { |
|
result.content = result.content.slice(1); |
|
result.index++; |
|
} // If we matched a trailing `]`, strip it from the match. |
|
|
|
|
|
if (match[7]) { |
|
result.content = result.content.slice(0, -1); |
|
} |
|
|
|
return result; |
|
} |
|
/** |
|
* Replace matching shortcodes in a block of text. |
|
* |
|
* @param {string} tag Shortcode tag. |
|
* @param {string} text Text to search. |
|
* @param {Function} callback Function to process the match and return |
|
* replacement string. |
|
* |
|
* @return {string} Text with shortcodes replaced. |
|
*/ |
|
|
|
function replace(tag, text, callback) { |
|
var _arguments = arguments; |
|
return text.replace(regexp(tag), function (match, left, $3, attrs, slash, content, closing, right) { |
|
// If both extra brackets exist, the shortcode has been properly |
|
// escaped. |
|
if (left === '[' && right === ']') { |
|
return match; |
|
} // Create the match object and pass it through the callback. |
|
|
|
|
|
var result = callback(fromMatch(_arguments)); // Make sure to return any of the extra brackets if they weren't used to |
|
// escape the shortcode. |
|
|
|
return result ? left + result + right : match; |
|
}); |
|
} |
|
/** |
|
* Generate a string from shortcode parameters. |
|
* |
|
* Creates a shortcode instance and returns a string. |
|
* |
|
* Accepts the same `options` as the `shortcode()` constructor, containing a |
|
* `tag` string, a string or object of `attrs`, a boolean indicating whether to |
|
* format the shortcode using a `single` tag, and a `content` string. |
|
* |
|
* @param {Object} options |
|
* |
|
* @return {string} String representation of the shortcode. |
|
*/ |
|
|
|
function string(options) { |
|
return new shortcode(options).string(); |
|
} |
|
/** |
|
* Generate a RegExp to identify a shortcode. |
|
* |
|
* The base regex is functionally equivalent to the one found in |
|
* `get_shortcode_regex()` in `wp-includes/shortcodes.php`. |
|
* |
|
* Capture groups: |
|
* |
|
* 1. An extra `[` to allow for escaping shortcodes with double `[[]]` |
|
* 2. The shortcode name |
|
* 3. The shortcode argument list |
|
* 4. The self closing `/` |
|
* 5. The content of a shortcode when it wraps some content. |
|
* 6. The closing tag. |
|
* 7. An extra `]` to allow for escaping shortcodes with double `[[]]` |
|
* |
|
* @param {string} tag Shortcode tag. |
|
* |
|
* @return {RegExp} Shortcode RegExp. |
|
*/ |
|
|
|
function regexp(tag) { |
|
return new RegExp('\\[(\\[?)(' + tag + ')(?![\\w-])([^\\]\\/]*(?:\\/(?!\\])[^\\]\\/]*)*?)(?:(\\/)\\]|\\](?:([^\\[]*(?:\\[(?!\\/\\2\\])[^\\[]*)*)(\\[\\/\\2\\]))?)(\\]?)', 'g'); |
|
} |
|
/** |
|
* Parse shortcode attributes. |
|
* |
|
* Shortcodes accept many types of attributes. These can chiefly be divided into |
|
* named and numeric attributes: |
|
* |
|
* Named attributes are assigned on a key/value basis, while numeric attributes |
|
* are treated as an array. |
|
* |
|
* Named attributes can be formatted as either `name="value"`, `name='value'`, |
|
* or `name=value`. Numeric attributes can be formatted as `"value"` or just |
|
* `value`. |
|
* |
|
* @param {string} text Serialised shortcode attributes. |
|
* |
|
* @return {WPShortcodeAttrs} Parsed shortcode attributes. |
|
*/ |
|
|
|
var attrs = memize__WEBPACK_IMPORTED_MODULE_1___default()(function (text) { |
|
var named = {}; |
|
var numeric = []; // This regular expression is reused from `shortcode_parse_atts()` in |
|
// `wp-includes/shortcodes.php`. |
|
// |
|
// Capture groups: |
|
// |
|
// 1. An attribute name, that corresponds to... |
|
// 2. a value in double quotes. |
|
// 3. An attribute name, that corresponds to... |
|
// 4. a value in single quotes. |
|
// 5. An attribute name, that corresponds to... |
|
// 6. an unquoted value. |
|
// 7. A numeric attribute in double quotes. |
|
// 8. A numeric attribute in single quotes. |
|
// 9. An unquoted numeric attribute. |
|
|
|
var pattern = /([\w-]+)\s*=\s*"([^"]*)"(?:\s|$)|([\w-]+)\s*=\s*'([^']*)'(?:\s|$)|([\w-]+)\s*=\s*([^\s'"]+)(?:\s|$)|"([^"]*)"(?:\s|$)|'([^']*)'(?:\s|$)|(\S+)(?:\s|$)/g; // Map zero-width spaces to actual spaces. |
|
|
|
text = text.replace(/[\u00a0\u200b]/g, ' '); |
|
var match; // Match and normalize attributes. |
|
|
|
while (match = pattern.exec(text)) { |
|
if (match[1]) { |
|
named[match[1].toLowerCase()] = match[2]; |
|
} else if (match[3]) { |
|
named[match[3].toLowerCase()] = match[4]; |
|
} else if (match[5]) { |
|
named[match[5].toLowerCase()] = match[6]; |
|
} else if (match[7]) { |
|
numeric.push(match[7]); |
|
} else if (match[8]) { |
|
numeric.push(match[8]); |
|
} else if (match[9]) { |
|
numeric.push(match[9]); |
|
} |
|
} |
|
|
|
return { |
|
named: named, |
|
numeric: numeric |
|
}; |
|
}); |
|
/** |
|
* Generate a Shortcode Object from a RegExp match. |
|
* |
|
* Accepts a `match` object from calling `regexp.exec()` on a `RegExp` generated |
|
* by `regexp()`. `match` can also be set to the `arguments` from a callback |
|
* passed to `regexp.replace()`. |
|
* |
|
* @param {Array} match Match array. |
|
* |
|
* @return {WPShortcode} Shortcode instance. |
|
*/ |
|
|
|
function fromMatch(match) { |
|
var type; |
|
|
|
if (match[4]) { |
|
type = 'self-closing'; |
|
} else if (match[6]) { |
|
type = 'closed'; |
|
} else { |
|
type = 'single'; |
|
} |
|
|
|
return new shortcode({ |
|
tag: match[2], |
|
attrs: match[3], |
|
type: type, |
|
content: match[5] |
|
}); |
|
} |
|
/** |
|
* Creates a shortcode instance. |
|
* |
|
* To access a raw representation of a shortcode, pass an `options` object, |
|
* containing a `tag` string, a string or object of `attrs`, a string indicating |
|
* the `type` of the shortcode ('single', 'self-closing', or 'closed'), and a |
|
* `content` string. |
|
* |
|
* @param {Object} options Options as described. |
|
* |
|
* @return {WPShortcode} Shortcode instance. |
|
*/ |
|
|
|
var shortcode = Object(lodash__WEBPACK_IMPORTED_MODULE_0__["extend"])(function (options) { |
|
var _this = this; |
|
|
|
Object(lodash__WEBPACK_IMPORTED_MODULE_0__["extend"])(this, Object(lodash__WEBPACK_IMPORTED_MODULE_0__["pick"])(options || {}, 'tag', 'attrs', 'type', 'content')); |
|
var attributes = this.attrs; // Ensure we have a correctly formatted `attrs` object. |
|
|
|
this.attrs = { |
|
named: {}, |
|
numeric: [] |
|
}; |
|
|
|
if (!attributes) { |
|
return; |
|
} // Parse a string of attributes. |
|
|
|
|
|
if (Object(lodash__WEBPACK_IMPORTED_MODULE_0__["isString"])(attributes)) { |
|
this.attrs = attrs(attributes); // Identify a correctly formatted `attrs` object. |
|
} else if (Object(lodash__WEBPACK_IMPORTED_MODULE_0__["isEqual"])(Object.keys(attributes), ['named', 'numeric'])) { |
|
this.attrs = attributes; // Handle a flat object of attributes. |
|
} else { |
|
Object(lodash__WEBPACK_IMPORTED_MODULE_0__["forEach"])(attributes, function (value, key) { |
|
_this.set(key, value); |
|
}); |
|
} |
|
}, { |
|
next: next, |
|
replace: replace, |
|
string: string, |
|
regexp: regexp, |
|
attrs: attrs, |
|
fromMatch: fromMatch |
|
}); |
|
Object(lodash__WEBPACK_IMPORTED_MODULE_0__["extend"])(shortcode.prototype, { |
|
/** |
|
* Get a shortcode attribute. |
|
* |
|
* Automatically detects whether `attr` is named or numeric and routes it |
|
* accordingly. |
|
* |
|
* @param {(number|string)} attr Attribute key. |
|
* |
|
* @return {string} Attribute value. |
|
*/ |
|
get: function get(attr) { |
|
return this.attrs[Object(lodash__WEBPACK_IMPORTED_MODULE_0__["isNumber"])(attr) ? 'numeric' : 'named'][attr]; |
|
}, |
|
|
|
/** |
|
* Set a shortcode attribute. |
|
* |
|
* Automatically detects whether `attr` is named or numeric and routes it |
|
* accordingly. |
|
* |
|
* @param {(number|string)} attr Attribute key. |
|
* @param {string} value Attribute value. |
|
* |
|
* @return {WPShortcode} Shortcode instance. |
|
*/ |
|
set: function set(attr, value) { |
|
this.attrs[Object(lodash__WEBPACK_IMPORTED_MODULE_0__["isNumber"])(attr) ? 'numeric' : 'named'][attr] = value; |
|
return this; |
|
}, |
|
|
|
/** |
|
* Transform the shortcode into a string. |
|
* |
|
* @return {string} String representation of the shortcode. |
|
*/ |
|
string: function string() { |
|
var text = '[' + this.tag; |
|
Object(lodash__WEBPACK_IMPORTED_MODULE_0__["forEach"])(this.attrs.numeric, function (value) { |
|
if (/\s/.test(value)) { |
|
text += ' "' + value + '"'; |
|
} else { |
|
text += ' ' + value; |
|
} |
|
}); |
|
Object(lodash__WEBPACK_IMPORTED_MODULE_0__["forEach"])(this.attrs.named, function (value, name) { |
|
text += ' ' + name + '="' + value + '"'; |
|
}); // If the tag is marked as `single` or `self-closing`, close the tag and |
|
// ignore any additional content. |
|
|
|
if ('single' === this.type) { |
|
return text + ']'; |
|
} else if ('self-closing' === this.type) { |
|
return text + ' /]'; |
|
} // Complete the opening tag. |
|
|
|
|
|
text += ']'; |
|
|
|
if (this.content) { |
|
text += this.content; |
|
} // Add the closing tag. |
|
|
|
|
|
return text + '[/' + this.tag + ']'; |
|
} |
|
}); |
|
/* harmony default export */ __webpack_exports__["default"] = (shortcode); |
|
|
|
|
|
/***/ }), |
|
|
|
/***/ 41: |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
module.exports = function memize( fn, options ) { |
|
var size = 0, |
|
maxSize, head, tail; |
|
|
|
if ( options && options.maxSize ) { |
|
maxSize = options.maxSize; |
|
} |
|
|
|
function memoized( /* ...args */ ) { |
|
var node = head, |
|
len = arguments.length, |
|
args, i; |
|
|
|
searchCache: while ( node ) { |
|
// Perform a shallow equality test to confirm that whether the node |
|
// under test is a candidate for the arguments passed. Two arrays |
|
// are shallowly equal if their length matches and each entry is |
|
// strictly equal between the two sets. Avoid abstracting to a |
|
// function which could incur an arguments leaking deoptimization. |
|
|
|
// Check whether node arguments match arguments length |
|
if ( node.args.length !== arguments.length ) { |
|
node = node.next; |
|
continue; |
|
} |
|
|
|
// Check whether node arguments match arguments values |
|
for ( i = 0; i < len; i++ ) { |
|
if ( node.args[ i ] !== arguments[ i ] ) { |
|
node = node.next; |
|
continue searchCache; |
|
} |
|
} |
|
|
|
// At this point we can assume we've found a match |
|
|
|
// Surface matched node to head if not already |
|
if ( node !== head ) { |
|
// As tail, shift to previous. Must only shift if not also |
|
// head, since if both head and tail, there is no previous. |
|
if ( node === tail ) { |
|
tail = node.prev; |
|
} |
|
|
|
// Adjust siblings to point to each other. If node was tail, |
|
// this also handles new tail's empty `next` assignment. |
|
node.prev.next = node.next; |
|
if ( node.next ) { |
|
node.next.prev = node.prev; |
|
} |
|
|
|
node.next = head; |
|
node.prev = null; |
|
head.prev = node; |
|
head = node; |
|
} |
|
|
|
// Return immediately |
|
return node.val; |
|
} |
|
|
|
// No cached value found. Continue to insertion phase: |
|
|
|
// Create a copy of arguments (avoid leaking deoptimization) |
|
args = new Array( len ); |
|
for ( i = 0; i < len; i++ ) { |
|
args[ i ] = arguments[ i ]; |
|
} |
|
|
|
node = { |
|
args: args, |
|
|
|
// Generate the result from original function |
|
val: fn.apply( null, args ) |
|
}; |
|
|
|
// Don't need to check whether node is already head, since it would |
|
// have been returned above already if it was |
|
|
|
// Shift existing head down list |
|
if ( head ) { |
|
head.prev = node; |
|
node.next = head; |
|
} else { |
|
// If no head, follows that there's no tail (at initial or reset) |
|
tail = node; |
|
} |
|
|
|
// Trim tail if we're reached max size and are pending cache insertion |
|
if ( size === maxSize ) { |
|
tail = tail.prev; |
|
tail.next = null; |
|
} else { |
|
size++; |
|
} |
|
|
|
head = node; |
|
|
|
return node.val; |
|
} |
|
|
|
memoized.clear = function() { |
|
head = null; |
|
tail = null; |
|
size = 0; |
|
}; |
|
|
|
if ( false ) {} |
|
|
|
return memoized; |
|
}; |
|
|
|
|
|
/***/ }) |
|
|
|
/******/ }); |