| 1 |
/******/ (() => { // webpackBootstrap |
| 2 |
/******/ "use strict"; |
| 3 |
/******/ // The require scope |
| 4 |
/******/ var __webpack_require__ = {}; |
| 5 |
/******/ |
| 6 |
/************************************************************************/ |
| 7 |
/******/ /* webpack/runtime/compat get default export */ |
| 8 |
/******/ (() => { |
| 9 |
/******/ // getDefaultExport function for compatibility with non-harmony modules |
| 10 |
/******/ __webpack_require__.n = (module) => { |
| 11 |
/******/ var getter = module && module.__esModule ? |
| 12 |
/******/ () => (module['default']) : |
| 13 |
/******/ () => (module); |
| 14 |
/******/ __webpack_require__.d(getter, { a: getter }); |
| 15 |
/******/ return getter; |
| 16 |
/******/ }; |
| 17 |
/******/ })(); |
| 18 |
/******/ |
| 19 |
/******/ /* webpack/runtime/define property getters */ |
| 20 |
/******/ (() => { |
| 21 |
/******/ // define getter functions for harmony exports |
| 22 |
/******/ __webpack_require__.d = (exports, definition) => { |
| 23 |
/******/ for(var key in definition) { |
| 24 |
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { |
| 25 |
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); |
| 26 |
/******/ } |
| 27 |
/******/ } |
| 28 |
/******/ }; |
| 29 |
/******/ })(); |
| 30 |
/******/ |
| 31 |
/******/ /* webpack/runtime/hasOwnProperty shorthand */ |
| 32 |
/******/ (() => { |
| 33 |
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) |
| 34 |
/******/ })(); |
| 35 |
/******/ |
| 36 |
/******/ /* webpack/runtime/make namespace object */ |
| 37 |
/******/ (() => { |
| 38 |
/******/ // define __esModule on exports |
| 39 |
/******/ __webpack_require__.r = (exports) => { |
| 40 |
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { |
| 41 |
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); |
| 42 |
/******/ } |
| 43 |
/******/ Object.defineProperty(exports, '__esModule', { value: true }); |
| 44 |
/******/ }; |
| 45 |
/******/ })(); |
| 46 |
/******/ |
| 47 |
/************************************************************************/ |
| 48 |
var __webpack_exports__ = {}; |
| 49 |
// ESM COMPAT FLAG |
| 50 |
__webpack_require__.r(__webpack_exports__); |
| 51 |
|
| 52 |
;// CONCATENATED MODULE: external ["wp","element"] |
| 53 |
const external_wp_element_namespaceObject = window["wp"]["element"]; |
| 54 |
;// CONCATENATED MODULE: external ["wp","i18n"] |
| 55 |
const external_wp_i18n_namespaceObject = window["wp"]["i18n"]; |
| 56 |
;// CONCATENATED MODULE: ./node_modules/tslib/tslib.es6.mjs |
| 57 |
/****************************************************************************** |
| 58 |
Copyright (c) Microsoft Corporation. |
| 59 |
|
| 60 |
Permission to use, copy, modify, and/or distribute this software for any |
| 61 |
purpose with or without fee is hereby granted. |
| 62 |
|
| 63 |
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH |
| 64 |
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY |
| 65 |
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, |
| 66 |
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM |
| 67 |
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR |
| 68 |
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| 69 |
PERFORMANCE OF THIS SOFTWARE. |
| 70 |
***************************************************************************** */ |
| 71 |
/* global Reflect, Promise, SuppressedError, Symbol */ |
| 72 |
|
| 73 |
var extendStatics = function(d, b) { |
| 74 |
extendStatics = Object.setPrototypeOf || |
| 75 |
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || |
| 76 |
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; |
| 77 |
return extendStatics(d, b); |
| 78 |
}; |
| 79 |
|
| 80 |
function __extends(d, b) { |
| 81 |
if (typeof b !== "function" && b !== null) |
| 82 |
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); |
| 83 |
extendStatics(d, b); |
| 84 |
function __() { this.constructor = d; } |
| 85 |
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); |
| 86 |
} |
| 87 |
|
| 88 |
var __assign = function() { |
| 89 |
__assign = Object.assign || function __assign(t) { |
| 90 |
for (var s, i = 1, n = arguments.length; i < n; i++) { |
| 91 |
s = arguments[i]; |
| 92 |
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; |
| 93 |
} |
| 94 |
return t; |
| 95 |
} |
| 96 |
return __assign.apply(this, arguments); |
| 97 |
} |
| 98 |
|
| 99 |
function __rest(s, e) { |
| 100 |
var t = {}; |
| 101 |
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) |
| 102 |
t[p] = s[p]; |
| 103 |
if (s != null && typeof Object.getOwnPropertySymbols === "function") |
| 104 |
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { |
| 105 |
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) |
| 106 |
t[p[i]] = s[p[i]]; |
| 107 |
} |
| 108 |
return t; |
| 109 |
} |
| 110 |
|
| 111 |
function __decorate(decorators, target, key, desc) { |
| 112 |
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; |
| 113 |
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); |
| 114 |
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; |
| 115 |
return c > 3 && r && Object.defineProperty(target, key, r), r; |
| 116 |
} |
| 117 |
|
| 118 |
function __param(paramIndex, decorator) { |
| 119 |
return function (target, key) { decorator(target, key, paramIndex); } |
| 120 |
} |
| 121 |
|
| 122 |
function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) { |
| 123 |
function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; } |
| 124 |
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value"; |
| 125 |
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null; |
| 126 |
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {}); |
| 127 |
var _, done = false; |
| 128 |
for (var i = decorators.length - 1; i >= 0; i--) { |
| 129 |
var context = {}; |
| 130 |
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p]; |
| 131 |
for (var p in contextIn.access) context.access[p] = contextIn.access[p]; |
| 132 |
context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); }; |
| 133 |
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context); |
| 134 |
if (kind === "accessor") { |
| 135 |
if (result === void 0) continue; |
| 136 |
if (result === null || typeof result !== "object") throw new TypeError("Object expected"); |
| 137 |
if (_ = accept(result.get)) descriptor.get = _; |
| 138 |
if (_ = accept(result.set)) descriptor.set = _; |
| 139 |
if (_ = accept(result.init)) initializers.unshift(_); |
| 140 |
} |
| 141 |
else if (_ = accept(result)) { |
| 142 |
if (kind === "field") initializers.unshift(_); |
| 143 |
else descriptor[key] = _; |
| 144 |
} |
| 145 |
} |
| 146 |
if (target) Object.defineProperty(target, contextIn.name, descriptor); |
| 147 |
done = true; |
| 148 |
}; |
| 149 |
|
| 150 |
function __runInitializers(thisArg, initializers, value) { |
| 151 |
var useValue = arguments.length > 2; |
| 152 |
for (var i = 0; i < initializers.length; i++) { |
| 153 |
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg); |
| 154 |
} |
| 155 |
return useValue ? value : void 0; |
| 156 |
}; |
| 157 |
|
| 158 |
function __propKey(x) { |
| 159 |
return typeof x === "symbol" ? x : "".concat(x); |
| 160 |
}; |
| 161 |
|
| 162 |
function __setFunctionName(f, name, prefix) { |
| 163 |
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; |
| 164 |
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); |
| 165 |
}; |
| 166 |
|
| 167 |
function __metadata(metadataKey, metadataValue) { |
| 168 |
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue); |
| 169 |
} |
| 170 |
|
| 171 |
function __awaiter(thisArg, _arguments, P, generator) { |
| 172 |
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } |
| 173 |
return new (P || (P = Promise))(function (resolve, reject) { |
| 174 |
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } |
| 175 |
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } |
| 176 |
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } |
| 177 |
step((generator = generator.apply(thisArg, _arguments || [])).next()); |
| 178 |
}); |
| 179 |
} |
| 180 |
|
| 181 |
function __generator(thisArg, body) { |
| 182 |
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; |
| 183 |
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; |
| 184 |
function verb(n) { return function (v) { return step([n, v]); }; } |
| 185 |
function step(op) { |
| 186 |
if (f) throw new TypeError("Generator is already executing."); |
| 187 |
while (g && (g = 0, op[0] && (_ = 0)), _) try { |
| 188 |
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; |
| 189 |
if (y = 0, t) op = [op[0] & 2, t.value]; |
| 190 |
switch (op[0]) { |
| 191 |
case 0: case 1: t = op; break; |
| 192 |
case 4: _.label++; return { value: op[1], done: false }; |
| 193 |
case 5: _.label++; y = op[1]; op = [0]; continue; |
| 194 |
case 7: op = _.ops.pop(); _.trys.pop(); continue; |
| 195 |
default: |
| 196 |
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } |
| 197 |
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } |
| 198 |
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } |
| 199 |
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } |
| 200 |
if (t[2]) _.ops.pop(); |
| 201 |
_.trys.pop(); continue; |
| 202 |
} |
| 203 |
op = body.call(thisArg, _); |
| 204 |
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } |
| 205 |
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; |
| 206 |
} |
| 207 |
} |
| 208 |
|
| 209 |
var __createBinding = Object.create ? (function(o, m, k, k2) { |
| 210 |
if (k2 === undefined) k2 = k; |
| 211 |
var desc = Object.getOwnPropertyDescriptor(m, k); |
| 212 |
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { |
| 213 |
desc = { enumerable: true, get: function() { return m[k]; } }; |
| 214 |
} |
| 215 |
Object.defineProperty(o, k2, desc); |
| 216 |
}) : (function(o, m, k, k2) { |
| 217 |
if (k2 === undefined) k2 = k; |
| 218 |
o[k2] = m[k]; |
| 219 |
}); |
| 220 |
|
| 221 |
function __exportStar(m, o) { |
| 222 |
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p); |
| 223 |
} |
| 224 |
|
| 225 |
function __values(o) { |
| 226 |
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; |
| 227 |
if (m) return m.call(o); |
| 228 |
if (o && typeof o.length === "number") return { |
| 229 |
next: function () { |
| 230 |
if (o && i >= o.length) o = void 0; |
| 231 |
return { value: o && o[i++], done: !o }; |
| 232 |
} |
| 233 |
}; |
| 234 |
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); |
| 235 |
} |
| 236 |
|
| 237 |
function __read(o, n) { |
| 238 |
var m = typeof Symbol === "function" && o[Symbol.iterator]; |
| 239 |
if (!m) return o; |
| 240 |
var i = m.call(o), r, ar = [], e; |
| 241 |
try { |
| 242 |
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); |
| 243 |
} |
| 244 |
catch (error) { e = { error: error }; } |
| 245 |
finally { |
| 246 |
try { |
| 247 |
if (r && !r.done && (m = i["return"])) m.call(i); |
| 248 |
} |
| 249 |
finally { if (e) throw e.error; } |
| 250 |
} |
| 251 |
return ar; |
| 252 |
} |
| 253 |
|
| 254 |
/** @deprecated */ |
| 255 |
function __spread() { |
| 256 |
for (var ar = [], i = 0; i < arguments.length; i++) |
| 257 |
ar = ar.concat(__read(arguments[i])); |
| 258 |
return ar; |
| 259 |
} |
| 260 |
|
| 261 |
/** @deprecated */ |
| 262 |
function __spreadArrays() { |
| 263 |
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; |
| 264 |
for (var r = Array(s), k = 0, i = 0; i < il; i++) |
| 265 |
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) |
| 266 |
r[k] = a[j]; |
| 267 |
return r; |
| 268 |
} |
| 269 |
|
| 270 |
function __spreadArray(to, from, pack) { |
| 271 |
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { |
| 272 |
if (ar || !(i in from)) { |
| 273 |
if (!ar) ar = Array.prototype.slice.call(from, 0, i); |
| 274 |
ar[i] = from[i]; |
| 275 |
} |
| 276 |
} |
| 277 |
return to.concat(ar || Array.prototype.slice.call(from)); |
| 278 |
} |
| 279 |
|
| 280 |
function __await(v) { |
| 281 |
return this instanceof __await ? (this.v = v, this) : new __await(v); |
| 282 |
} |
| 283 |
|
| 284 |
function __asyncGenerator(thisArg, _arguments, generator) { |
| 285 |
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); |
| 286 |
var g = generator.apply(thisArg, _arguments || []), i, q = []; |
| 287 |
return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i; |
| 288 |
function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; } |
| 289 |
function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } } |
| 290 |
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } |
| 291 |
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } |
| 292 |
function fulfill(value) { resume("next", value); } |
| 293 |
function reject(value) { resume("throw", value); } |
| 294 |
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } |
| 295 |
} |
| 296 |
|
| 297 |
function __asyncDelegator(o) { |
| 298 |
var i, p; |
| 299 |
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; |
| 300 |
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; } |
| 301 |
} |
| 302 |
|
| 303 |
function __asyncValues(o) { |
| 304 |
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); |
| 305 |
var m = o[Symbol.asyncIterator], i; |
| 306 |
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); |
| 307 |
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } |
| 308 |
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } |
| 309 |
} |
| 310 |
|
| 311 |
function __makeTemplateObject(cooked, raw) { |
| 312 |
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } |
| 313 |
return cooked; |
| 314 |
}; |
| 315 |
|
| 316 |
var __setModuleDefault = Object.create ? (function(o, v) { |
| 317 |
Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| 318 |
}) : function(o, v) { |
| 319 |
o["default"] = v; |
| 320 |
}; |
| 321 |
|
| 322 |
function __importStar(mod) { |
| 323 |
if (mod && mod.__esModule) return mod; |
| 324 |
var result = {}; |
| 325 |
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| 326 |
__setModuleDefault(result, mod); |
| 327 |
return result; |
| 328 |
} |
| 329 |
|
| 330 |
function __importDefault(mod) { |
| 331 |
return (mod && mod.__esModule) ? mod : { default: mod }; |
| 332 |
} |
| 333 |
|
| 334 |
function __classPrivateFieldGet(receiver, state, kind, f) { |
| 335 |
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); |
| 336 |
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); |
| 337 |
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); |
| 338 |
} |
| 339 |
|
| 340 |
function __classPrivateFieldSet(receiver, state, value, kind, f) { |
| 341 |
if (kind === "m") throw new TypeError("Private method is not writable"); |
| 342 |
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); |
| 343 |
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); |
| 344 |
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; |
| 345 |
} |
| 346 |
|
| 347 |
function __classPrivateFieldIn(state, receiver) { |
| 348 |
if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object"); |
| 349 |
return typeof state === "function" ? receiver === state : state.has(receiver); |
| 350 |
} |
| 351 |
|
| 352 |
function __addDisposableResource(env, value, async) { |
| 353 |
if (value !== null && value !== void 0) { |
| 354 |
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected."); |
| 355 |
var dispose, inner; |
| 356 |
if (async) { |
| 357 |
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined."); |
| 358 |
dispose = value[Symbol.asyncDispose]; |
| 359 |
} |
| 360 |
if (dispose === void 0) { |
| 361 |
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined."); |
| 362 |
dispose = value[Symbol.dispose]; |
| 363 |
if (async) inner = dispose; |
| 364 |
} |
| 365 |
if (typeof dispose !== "function") throw new TypeError("Object not disposable."); |
| 366 |
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } }; |
| 367 |
env.stack.push({ value: value, dispose: dispose, async: async }); |
| 368 |
} |
| 369 |
else if (async) { |
| 370 |
env.stack.push({ async: true }); |
| 371 |
} |
| 372 |
return value; |
| 373 |
} |
| 374 |
|
| 375 |
var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { |
| 376 |
var e = new Error(message); |
| 377 |
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; |
| 378 |
}; |
| 379 |
|
| 380 |
function __disposeResources(env) { |
| 381 |
function fail(e) { |
| 382 |
env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e; |
| 383 |
env.hasError = true; |
| 384 |
} |
| 385 |
function next() { |
| 386 |
while (env.stack.length) { |
| 387 |
var rec = env.stack.pop(); |
| 388 |
try { |
| 389 |
var result = rec.dispose && rec.dispose.call(rec.value); |
| 390 |
if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); }); |
| 391 |
} |
| 392 |
catch (e) { |
| 393 |
fail(e); |
| 394 |
} |
| 395 |
} |
| 396 |
if (env.hasError) throw env.error; |
| 397 |
} |
| 398 |
return next(); |
| 399 |
} |
| 400 |
|
| 401 |
/* harmony default export */ const tslib_es6 = ({ |
| 402 |
__extends, |
| 403 |
__assign, |
| 404 |
__rest, |
| 405 |
__decorate, |
| 406 |
__param, |
| 407 |
__metadata, |
| 408 |
__awaiter, |
| 409 |
__generator, |
| 410 |
__createBinding, |
| 411 |
__exportStar, |
| 412 |
__values, |
| 413 |
__read, |
| 414 |
__spread, |
| 415 |
__spreadArrays, |
| 416 |
__spreadArray, |
| 417 |
__await, |
| 418 |
__asyncGenerator, |
| 419 |
__asyncDelegator, |
| 420 |
__asyncValues, |
| 421 |
__makeTemplateObject, |
| 422 |
__importStar, |
| 423 |
__importDefault, |
| 424 |
__classPrivateFieldGet, |
| 425 |
__classPrivateFieldSet, |
| 426 |
__classPrivateFieldIn, |
| 427 |
__addDisposableResource, |
| 428 |
__disposeResources, |
| 429 |
}); |
| 430 |
|
| 431 |
;// CONCATENATED MODULE: ./node_modules/lower-case/dist.es2015/index.js |
| 432 |
/** |
| 433 |
* Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt |
| 434 |
*/ |
| 435 |
var SUPPORTED_LOCALE = { |
| 436 |
tr: { |
| 437 |
regexp: /\u0130|\u0049|\u0049\u0307/g, |
| 438 |
map: { |
| 439 |
İ: "\u0069", |
| 440 |
I: "\u0131", |
| 441 |
İ: "\u0069", |
| 442 |
}, |
| 443 |
}, |
| 444 |
az: { |
| 445 |
regexp: /\u0130/g, |
| 446 |
map: { |
| 447 |
İ: "\u0069", |
| 448 |
I: "\u0131", |
| 449 |
İ: "\u0069", |
| 450 |
}, |
| 451 |
}, |
| 452 |
lt: { |
| 453 |
regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g, |
| 454 |
map: { |
| 455 |
I: "\u0069\u0307", |
| 456 |
J: "\u006A\u0307", |
| 457 |
Į: "\u012F\u0307", |
| 458 |
Ì: "\u0069\u0307\u0300", |
| 459 |
Í: "\u0069\u0307\u0301", |
| 460 |
Ĩ: "\u0069\u0307\u0303", |
| 461 |
}, |
| 462 |
}, |
| 463 |
}; |
| 464 |
/** |
| 465 |
* Localized lower case. |
| 466 |
*/ |
| 467 |
function localeLowerCase(str, locale) { |
| 468 |
var lang = SUPPORTED_LOCALE[locale.toLowerCase()]; |
| 469 |
if (lang) |
| 470 |
return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; })); |
| 471 |
return lowerCase(str); |
| 472 |
} |
| 473 |
/** |
| 474 |
* Lower case as a function. |
| 475 |
*/ |
| 476 |
function lowerCase(str) { |
| 477 |
return str.toLowerCase(); |
| 478 |
} |
| 479 |
|
| 480 |
;// CONCATENATED MODULE: ./node_modules/no-case/dist.es2015/index.js |
| 481 |
|
| 482 |
// Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case"). |
| 483 |
var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g]; |
| 484 |
// Remove all non-word characters. |
| 485 |
var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi; |
| 486 |
/** |
| 487 |
* Normalize the string into something other libraries can manipulate easier. |
| 488 |
*/ |
| 489 |
function noCase(input, options) { |
| 490 |
if (options === void 0) { options = {}; } |
| 491 |
var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d; |
| 492 |
var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0"); |
| 493 |
var start = 0; |
| 494 |
var end = result.length; |
| 495 |
// Trim the delimiter from around the output string. |
| 496 |
while (result.charAt(start) === "\0") |
| 497 |
start++; |
| 498 |
while (result.charAt(end - 1) === "\0") |
| 499 |
end--; |
| 500 |
// Transform each token independently. |
| 501 |
return result.slice(start, end).split("\0").map(transform).join(delimiter); |
| 502 |
} |
| 503 |
/** |
| 504 |
* Replace `re` in the input string with the replacement value. |
| 505 |
*/ |
| 506 |
function replace(input, re, value) { |
| 507 |
if (re instanceof RegExp) |
| 508 |
return input.replace(re, value); |
| 509 |
return re.reduce(function (input, re) { return input.replace(re, value); }, input); |
| 510 |
} |
| 511 |
|
| 512 |
;// CONCATENATED MODULE: ./node_modules/dot-case/dist.es2015/index.js |
| 513 |
|
| 514 |
|
| 515 |
function dotCase(input, options) { |
| 516 |
if (options === void 0) { options = {}; } |
| 517 |
return noCase(input, __assign({ delimiter: "." }, options)); |
| 518 |
} |
| 519 |
|
| 520 |
;// CONCATENATED MODULE: ./node_modules/param-case/dist.es2015/index.js |
| 521 |
|
| 522 |
|
| 523 |
function paramCase(input, options) { |
| 524 |
if (options === void 0) { options = {}; } |
| 525 |
return dotCase(input, __assign({ delimiter: "-" }, options)); |
| 526 |
} |
| 527 |
|
| 528 |
;// CONCATENATED MODULE: external ["wp","apiFetch"] |
| 529 |
const external_wp_apiFetch_namespaceObject = window["wp"]["apiFetch"]; |
| 530 |
var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_namespaceObject); |
| 531 |
;// CONCATENATED MODULE: external ["wp","blob"] |
| 532 |
const external_wp_blob_namespaceObject = window["wp"]["blob"]; |
| 533 |
;// CONCATENATED MODULE: ./packages/list-reusable-blocks/build-module/utils/export.js |
| 534 |
/** |
| 535 |
* External dependencies |
| 536 |
*/ |
| 537 |
|
| 538 |
|
| 539 |
/** |
| 540 |
* WordPress dependencies |
| 541 |
*/ |
| 542 |
|
| 543 |
|
| 544 |
/** |
| 545 |
* Internal dependencies |
| 546 |
*/ |
| 547 |
|
| 548 |
|
| 549 |
/** |
| 550 |
* Export a reusable block as a JSON file. |
| 551 |
* |
| 552 |
* @param {number} id |
| 553 |
*/ |
| 554 |
async function exportReusableBlock(id) { |
| 555 |
const postType = await external_wp_apiFetch_default()({ |
| 556 |
path: `/wp/v2/types/wp_block` |
| 557 |
}); |
| 558 |
const post = await external_wp_apiFetch_default()({ |
| 559 |
path: `/wp/v2/${postType.rest_base}/${id}?context=edit` |
| 560 |
}); |
| 561 |
const title = post.title.raw; |
| 562 |
const content = post.content.raw; |
| 563 |
const syncStatus = post.wp_pattern_sync_status; |
| 564 |
const fileContent = JSON.stringify({ |
| 565 |
__file: 'wp_block', |
| 566 |
title, |
| 567 |
content, |
| 568 |
syncStatus |
| 569 |
}, null, 2); |
| 570 |
const fileName = paramCase(title) + '.json'; |
| 571 |
(0,external_wp_blob_namespaceObject.downloadBlob)(fileName, fileContent, 'application/json'); |
| 572 |
} |
| 573 |
/* harmony default export */ const utils_export = (exportReusableBlock); |
| 574 |
|
| 575 |
;// CONCATENATED MODULE: external ["wp","compose"] |
| 576 |
const external_wp_compose_namespaceObject = window["wp"]["compose"]; |
| 577 |
;// CONCATENATED MODULE: external ["wp","components"] |
| 578 |
const external_wp_components_namespaceObject = window["wp"]["components"]; |
| 579 |
;// CONCATENATED MODULE: ./packages/list-reusable-blocks/build-module/utils/file.js |
| 580 |
/** |
| 581 |
* Reads the textual content of the given file. |
| 582 |
* |
| 583 |
* @param {File} file File. |
| 584 |
* @return {Promise<string>} Content of the file. |
| 585 |
*/ |
| 586 |
function readTextFile(file) { |
| 587 |
const reader = new window.FileReader(); |
| 588 |
return new Promise(resolve => { |
| 589 |
reader.onload = () => { |
| 590 |
resolve(reader.result); |
| 591 |
}; |
| 592 |
reader.readAsText(file); |
| 593 |
}); |
| 594 |
} |
| 595 |
|
| 596 |
;// CONCATENATED MODULE: ./packages/list-reusable-blocks/build-module/utils/import.js |
| 597 |
/** |
| 598 |
* WordPress dependencies |
| 599 |
*/ |
| 600 |
|
| 601 |
|
| 602 |
/** |
| 603 |
* Internal dependencies |
| 604 |
*/ |
| 605 |
|
| 606 |
|
| 607 |
/** |
| 608 |
* Import a reusable block from a JSON file. |
| 609 |
* |
| 610 |
* @param {File} file File. |
| 611 |
* @return {Promise} Promise returning the imported reusable block. |
| 612 |
*/ |
| 613 |
async function importReusableBlock(file) { |
| 614 |
const fileContent = await readTextFile(file); |
| 615 |
let parsedContent; |
| 616 |
try { |
| 617 |
parsedContent = JSON.parse(fileContent); |
| 618 |
} catch (e) { |
| 619 |
throw new Error('Invalid JSON file'); |
| 620 |
} |
| 621 |
if (parsedContent.__file !== 'wp_block' || !parsedContent.title || !parsedContent.content || typeof parsedContent.title !== 'string' || typeof parsedContent.content !== 'string' || parsedContent.syncStatus && typeof parsedContent.syncStatus !== 'string') { |
| 622 |
throw new Error('Invalid pattern JSON file'); |
| 623 |
} |
| 624 |
const postType = await external_wp_apiFetch_default()({ |
| 625 |
path: `/wp/v2/types/wp_block` |
| 626 |
}); |
| 627 |
const reusableBlock = await external_wp_apiFetch_default()({ |
| 628 |
path: `/wp/v2/${postType.rest_base}`, |
| 629 |
data: { |
| 630 |
title: parsedContent.title, |
| 631 |
content: parsedContent.content, |
| 632 |
status: 'publish', |
| 633 |
meta: parsedContent.syncStatus === 'unsynced' ? { |
| 634 |
wp_pattern_sync_status: parsedContent.syncStatus |
| 635 |
} : undefined |
| 636 |
}, |
| 637 |
method: 'POST' |
| 638 |
}); |
| 639 |
return reusableBlock; |
| 640 |
} |
| 641 |
/* harmony default export */ const utils_import = (importReusableBlock); |
| 642 |
|
| 643 |
;// CONCATENATED MODULE: external "ReactJSXRuntime" |
| 644 |
const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"]; |
| 645 |
;// CONCATENATED MODULE: ./packages/list-reusable-blocks/build-module/components/import-form/index.js |
| 646 |
/** |
| 647 |
* WordPress dependencies |
| 648 |
*/ |
| 649 |
|
| 650 |
|
| 651 |
|
| 652 |
|
| 653 |
|
| 654 |
/** |
| 655 |
* Internal dependencies |
| 656 |
*/ |
| 657 |
|
| 658 |
|
| 659 |
|
| 660 |
function ImportForm({ |
| 661 |
instanceId, |
| 662 |
onUpload |
| 663 |
}) { |
| 664 |
const inputId = 'list-reusable-blocks-import-form-' + instanceId; |
| 665 |
const formRef = (0,external_wp_element_namespaceObject.useRef)(); |
| 666 |
const [isLoading, setIsLoading] = (0,external_wp_element_namespaceObject.useState)(false); |
| 667 |
const [error, setError] = (0,external_wp_element_namespaceObject.useState)(null); |
| 668 |
const [file, setFile] = (0,external_wp_element_namespaceObject.useState)(null); |
| 669 |
const onChangeFile = event => { |
| 670 |
setFile(event.target.files[0]); |
| 671 |
setError(null); |
| 672 |
}; |
| 673 |
const onSubmit = event => { |
| 674 |
event.preventDefault(); |
| 675 |
if (!file) { |
| 676 |
return; |
| 677 |
} |
| 678 |
setIsLoading({ |
| 679 |
isLoading: true |
| 680 |
}); |
| 681 |
utils_import(file).then(reusableBlock => { |
| 682 |
if (!formRef) { |
| 683 |
return; |
| 684 |
} |
| 685 |
setIsLoading(false); |
| 686 |
onUpload(reusableBlock); |
| 687 |
}).catch(errors => { |
| 688 |
if (!formRef) { |
| 689 |
return; |
| 690 |
} |
| 691 |
let uiMessage; |
| 692 |
switch (errors.message) { |
| 693 |
case 'Invalid JSON file': |
| 694 |
uiMessage = (0,external_wp_i18n_namespaceObject.__)('Invalid JSON file'); |
| 695 |
break; |
| 696 |
case 'Invalid pattern JSON file': |
| 697 |
uiMessage = (0,external_wp_i18n_namespaceObject.__)('Invalid pattern JSON file'); |
| 698 |
break; |
| 699 |
default: |
| 700 |
uiMessage = (0,external_wp_i18n_namespaceObject.__)('Unknown error'); |
| 701 |
} |
| 702 |
setIsLoading(false); |
| 703 |
setError(uiMessage); |
| 704 |
}); |
| 705 |
}; |
| 706 |
const onDismissError = () => { |
| 707 |
setError(null); |
| 708 |
}; |
| 709 |
return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("form", { |
| 710 |
className: "list-reusable-blocks-import-form", |
| 711 |
onSubmit: onSubmit, |
| 712 |
ref: formRef, |
| 713 |
children: [error && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Notice, { |
| 714 |
status: "error", |
| 715 |
onRemove: () => onDismissError(), |
| 716 |
children: error |
| 717 |
}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("label", { |
| 718 |
htmlFor: inputId, |
| 719 |
className: "list-reusable-blocks-import-form__label", |
| 720 |
children: (0,external_wp_i18n_namespaceObject.__)('File') |
| 721 |
}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("input", { |
| 722 |
id: inputId, |
| 723 |
type: "file", |
| 724 |
onChange: onChangeFile |
| 725 |
}), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { |
| 726 |
type: "submit", |
| 727 |
isBusy: isLoading, |
| 728 |
accessibleWhenDisabled: true, |
| 729 |
disabled: !file || isLoading, |
| 730 |
variant: "secondary", |
| 731 |
className: "list-reusable-blocks-import-form__button", |
| 732 |
children: (0,external_wp_i18n_namespaceObject._x)('Import', 'button label') |
| 733 |
})] |
| 734 |
}); |
| 735 |
} |
| 736 |
/* harmony default export */ const import_form = ((0,external_wp_compose_namespaceObject.withInstanceId)(ImportForm)); |
| 737 |
|
| 738 |
;// CONCATENATED MODULE: ./packages/list-reusable-blocks/build-module/components/import-dropdown/index.js |
| 739 |
/** |
| 740 |
* WordPress dependencies |
| 741 |
*/ |
| 742 |
|
| 743 |
|
| 744 |
|
| 745 |
|
| 746 |
/** |
| 747 |
* Internal dependencies |
| 748 |
*/ |
| 749 |
|
| 750 |
|
| 751 |
function ImportDropdown({ |
| 752 |
onUpload |
| 753 |
}) { |
| 754 |
return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, { |
| 755 |
popoverProps: { |
| 756 |
placement: 'bottom-start' |
| 757 |
}, |
| 758 |
contentClassName: "list-reusable-blocks-import-dropdown__content", |
| 759 |
renderToggle: ({ |
| 760 |
isOpen, |
| 761 |
onToggle |
| 762 |
}) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, { |
| 763 |
"aria-expanded": isOpen, |
| 764 |
onClick: onToggle, |
| 765 |
variant: "primary", |
| 766 |
children: (0,external_wp_i18n_namespaceObject.__)('Import from JSON') |
| 767 |
}), |
| 768 |
renderContent: ({ |
| 769 |
onClose |
| 770 |
}) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(import_form, { |
| 771 |
onUpload: (0,external_wp_compose_namespaceObject.pipe)(onClose, onUpload) |
| 772 |
}) |
| 773 |
}); |
| 774 |
} |
| 775 |
/* harmony default export */ const import_dropdown = (ImportDropdown); |
| 776 |
|
| 777 |
;// CONCATENATED MODULE: ./packages/list-reusable-blocks/build-module/index.js |
| 778 |
/** |
| 779 |
* WordPress dependencies |
| 780 |
*/ |
| 781 |
|
| 782 |
|
| 783 |
|
| 784 |
/** |
| 785 |
* Internal dependencies |
| 786 |
*/ |
| 787 |
|
| 788 |
|
| 789 |
|
| 790 |
// Setup Export Links. |
| 791 |
|
| 792 |
document.body.addEventListener('click', event => { |
| 793 |
if (!event.target.classList.contains('wp-list-reusable-blocks__export')) { |
| 794 |
return; |
| 795 |
} |
| 796 |
event.preventDefault(); |
| 797 |
utils_export(event.target.dataset.id); |
| 798 |
}); |
| 799 |
|
| 800 |
// Setup Import Form. |
| 801 |
document.addEventListener('DOMContentLoaded', () => { |
| 802 |
const button = document.querySelector('.page-title-action'); |
| 803 |
if (!button) { |
| 804 |
return; |
| 805 |
} |
| 806 |
const showNotice = () => { |
| 807 |
const notice = document.createElement('div'); |
| 808 |
notice.className = 'notice notice-success is-dismissible'; |
| 809 |
notice.innerHTML = `<p>${(0,external_wp_i18n_namespaceObject.__)('Pattern imported successfully!')}</p>`; |
| 810 |
const headerEnd = document.querySelector('.wp-header-end'); |
| 811 |
if (!headerEnd) { |
| 812 |
return; |
| 813 |
} |
| 814 |
headerEnd.parentNode.insertBefore(notice, headerEnd); |
| 815 |
}; |
| 816 |
const container = document.createElement('div'); |
| 817 |
container.className = 'list-reusable-blocks__container'; |
| 818 |
button.parentNode.insertBefore(container, button); |
| 819 |
(0,external_wp_element_namespaceObject.createRoot)(container).render( /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.StrictMode, { |
| 820 |
children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(import_dropdown, { |
| 821 |
onUpload: showNotice |
| 822 |
}) |
| 823 |
})); |
| 824 |
}); |
| 825 |
|
| 826 |
(window.wp = window.wp || {}).listReusableBlocks = __webpack_exports__; |
| 827 |
/******/ })() |
| 828 |
; |
