Gutenberg / 23.8.0

Gutenberg v23.8.0

gutenberg / build / scripts / shortcode / index.js

index.js in Gutenberg 23.8.0, at build/scripts/shortcode/index.js

300 lines 8.1 KB

Raw Download Zip

1	(function() {
2	"use strict";
3	var wp;
4	(wp \|\|= {}).shortcode = (() => {
5	var __defProp = Object.defineProperty;
6	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
7	var __getOwnPropNames = Object.getOwnPropertyNames;
8	var __hasOwnProp = Object.prototype.hasOwnProperty;
9	var __export = (target, all) => {
10	for (var name in all)
11	__defProp(target, name, { get: all[name], enumerable: true });
12	};
13	var __copyProps = (to, from, except, desc) => {
14	if (from && typeof from === "object" \|\| typeof from === "function") {
15	for (let key of __getOwnPropNames(from))
16	if (!__hasOwnProp.call(to, key) && key !== except)
17	__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
18	}
19	return to;
20	};
21	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
22
23	// packages/shortcode/build-module/index.mjs
24	var index_exports = {};
25	__export(index_exports, {
26	attrs: () => attrs,
27	default: () => index_default,
28	fromMatch: () => fromMatch,
29	next: () => next,
30	regexp: () => regexp,
31	replace: () => replace,
32	string: () => string
33	});
34
35	// node_modules/memize/dist/index.js
36	function memize(fn, options) {
37	var size = 0;
38	var head;
39	var tail;
40	options = options \|\| {};
41	function memoized() {
42	var node = head, len = arguments.length, args, i;
43	searchCache: while (node) {
44	if (node.args.length !== arguments.length) {
45	node = node.next;
46	continue;
47	}
48	for (i = 0; i < len; i++) {
49	if (node.args[i] !== arguments[i]) {
50	node = node.next;
51	continue searchCache;
52	}
53	}
54	if (node !== head) {
55	if (node === tail) {
56	tail = node.prev;
57	}
58	node.prev.next = node.next;
59	if (node.next) {
60	node.next.prev = node.prev;
61	}
62	node.next = head;
63	node.prev = null;
64	head.prev = node;
65	head = node;
66	}
67	return node.val;
68	}
69	args = new Array(len);
70	for (i = 0; i < len; i++) {
71	args[i] = arguments[i];
72	}
73	node = {
74	args,
75	// Generate the result from original function
76	val: fn.apply(null, args)
77	};
78	if (head) {
79	head.prev = node;
80	node.next = head;
81	} else {
82	tail = node;
83	}
84	if (size === /** @type {MemizeOptions} */
85	options.maxSize) {
86	tail = /** @type {MemizeCacheNode} */
87	tail.prev;
88	tail.next = null;
89	} else {
90	size++;
91	}
92	head = node;
93	return node.val;
94	}
95	memoized.clear = function() {
96	head = null;
97	tail = null;
98	size = 0;
99	};
100	return memoized;
101	}
102
103	// packages/shortcode/build-module/index.mjs
104	function next(tag, text, index = 0) {
105	const re = regexp(tag);
106	re.lastIndex = index;
107	const match = re.exec(text);
108	if (!match) {
109	return;
110	}
111	if ("[" === match[1] && "]" === match[7]) {
112	return next(tag, text, re.lastIndex);
113	}
114	const result = {
115	index: match.index,
116	content: match[0],
117	shortcode: fromMatch(match)
118	};
119	if (match[1]) {
120	result.content = result.content.slice(1);
121	result.index++;
122	}
123	if (match[7]) {
124	result.content = result.content.slice(0, -1);
125	}
126	return result;
127	}
128	function replace(tag, text, callback) {
129	return text.replace(
130	regexp(tag),
131	// Let us use spread syntax to capture the arguments object.
132	(...args) => {
133	const match = args[0];
134	const left = args[1];
135	const right = args[7];
136	if (left === "[" && right === "]") {
137	return match;
138	}
139	const result = callback(fromMatch(args));
140	return result \|\| result === "" ? left + result + right : match;
141	}
142	);
143	}
144	function string(options) {
145	return new Shortcode(options).string();
146	}
147	function regexp(tag) {
148	return new RegExp(
149	"\\[(\\[?)(" + tag + ")(?![\\w-])([^\\]\\/](?:\\/(?!\\])[^\\]\\/])?)(?:(\\/)\\]\|\\](?:([^\\[](?:\\[(?!\\/\\2\\])[^\\[]))(\\[\\/\\2\\]))?)(\\]?)",
150	"g"
151	);
152	}
153	var attrs = memize((text) => {
154	const named = {};
155	const numeric = [];
156	const pattern = /([\w-]+)\s=\s"([^"])"(?:\s\|$)\|([\w-]+)\s=\s'([^'])'(?:\s\|$)\|([\w-]+)\s=\s([^\s'"]+)(?:\s\|$)\|"([^"])"(?:\s\|$)\|'([^'])'(?:\s\|$)\|(\S+)(?:\s\|$)/g;
157	text = text.replace(/[\u00a0\u200b]/g, " ");
158	let match;
159	while (match = pattern.exec(text)) {
160	if (match[1]) {
161	named[match[1].toLowerCase()] = match[2];
162	} else if (match[3]) {
163	named[match[3].toLowerCase()] = match[4];
164	} else if (match[5]) {
165	named[match[5].toLowerCase()] = match[6];
166	} else if (match[7]) {
167	numeric.push(match[7]);
168	} else if (match[8]) {
169	numeric.push(match[8]);
170	} else if (match[9]) {
171	numeric.push(match[9]);
172	}
173	}
174	return { named, numeric };
175	});
176	function fromMatch(match) {
177	let type;
178	if (match[4]) {
179	type = "self-closing";
180	} else if (match[6]) {
181	type = "closed";
182	} else {
183	type = "single";
184	}
185	return new Shortcode({
186	tag: match[2],
187	attrs: match[3],
188	type,
189	content: match[5]
190	});
191	}
192	var Shortcode = class {
193	// Instance properties
194	tag;
195	type;
196	content;
197	attrs;
198	// Static methods
199	static next = next;
200	static replace = replace;
201	static string = string;
202	static regexp = regexp;
203	static attrs = attrs;
204	static fromMatch = fromMatch;
205	constructor(options) {
206	const { tag, attrs: attributes, type, content } = options;
207	this.tag = tag;
208	this.type = type;
209	this.content = content;
210	this.attrs = {
211	named: {},
212	numeric: []
213	};
214	if (!attributes) {
215	return;
216	}
217	if (typeof attributes === "string") {
218	this.attrs = attrs(attributes);
219	} else if ("named" in attributes && "numeric" in attributes && attributes.named !== void 0 && attributes.numeric !== void 0) {
220	this.attrs = attributes;
221	} else {
222	Object.entries(attributes).forEach(([key, value]) => {
223	if (value !== void 0) {
224	this.set(key, String(value));
225	}
226	});
227	}
228	}
229	/**
230	* Get a shortcode attribute.
231	*
232	* Automatically detects whether `attr` is named or numeric and routes it
233	* accordingly.
234	*
235	* @param attr Attribute key.
236	*
237	* @return Attribute value.
238	*/
239	get(attr) {
240	if (typeof attr === "number") {
241	return this.attrs.numeric[attr];
242	}
243	return this.attrs.named[attr];
244	}
245	/**
246	* Set a shortcode attribute.
247	*
248	* Automatically detects whether `attr` is named or numeric and routes it
249	* accordingly.
250	*
251	* @param attr Attribute key.
252	* @param value Attribute value.
253	*
254	* @return Shortcode instance.
255	*/
256	set(attr, value) {
257	if (typeof attr === "number") {
258	this.attrs.numeric[attr] = value;
259	} else {
260	this.attrs.named[attr] = value;
261	}
262	return this;
263	}
264	/**
265	* Transform the shortcode into a string.
266	*
267	* @return String representation of the shortcode.
268	*/
269	string() {
270	let text = "[" + this.tag;
271	this.attrs.numeric.forEach((value) => {
272	if (/\s/.test(value)) {
273	text += ' "' + value + '"';
274	} else {
275	text += " " + value;
276	}
277	});
278	Object.entries(this.attrs.named).forEach(([name, value]) => {
279	text += " " + name + '="' + value + '"';
280	});
281	if ("single" === this.type) {
282	return text + "]";
283	} else if ("self-closing" === this.type) {
284	return text + " /]";
285	}
286	text += "]";
287	if (this.content) {
288	text += this.content;
289	}
290	return text + "[/" + this.tag + "]";
291	}
292	};
293	var index_default = Shortcode;
294	return __toCommonJS(index_exports);
295	})();
296	if (typeof wp.shortcode === 'object' && wp.shortcode.default) { wp.shortcode = wp.shortcode.default; }
297	(window.wp \|\|= {}).shortcode = wp.shortcode;
298	})();
299	//# sourceMappingURL=index.js.map
300