902 lines
18 KiB
JavaScript
902 lines
18 KiB
JavaScript
/*!
|
|
* Tiny Commercial License Key Manager
|
|
*
|
|
* Copyright (c) 2025 Ephox Corporation DBA Tiny Technologies, Inc.
|
|
* Licensed under the Tiny commercial license. See https://www.tiny.cloud/legal/
|
|
*
|
|
* Version: 8.3.0-112
|
|
*/
|
|
(function () {
|
|
"use strict";
|
|
|
|
const e = Object.getPrototypeOf;
|
|
const r = (e, r, t) => !!t(e, r.prototype) || e.constructor?.name === r.name;
|
|
const t = (e) => (t) =>
|
|
((e) => {
|
|
const t = typeof e;
|
|
if (e === null) {
|
|
return "null";
|
|
} else if (t === "object" && Array.isArray(e)) {
|
|
return "array";
|
|
} else if (t === "object" && r(e, String, (e, r) => r.isPrototypeOf(e))) {
|
|
return "string";
|
|
} else {
|
|
return t;
|
|
}
|
|
})(t) === e;
|
|
const n = (e) => (r) => typeof r === e;
|
|
const o = t("string");
|
|
const s = t("object");
|
|
const a = (t) => ((t, n) => s(t) && r(t, n, (r, t) => e(r) === t))(t, Object);
|
|
const i = n("boolean");
|
|
const l = (e) => e == null;
|
|
const c = (e) => !l(e);
|
|
const u = n("function");
|
|
const y = n("number");
|
|
const d = () => {};
|
|
const g = (e) => () => e;
|
|
const p = (e) => e;
|
|
const h = (e) => e();
|
|
const m = g(false);
|
|
const v = g(true);
|
|
class f {
|
|
tag;
|
|
value;
|
|
static singletonNone = new f(false);
|
|
constructor(e, r) {
|
|
this.tag = e;
|
|
this.value = r;
|
|
}
|
|
static some(e) {
|
|
return new f(true, e);
|
|
}
|
|
static none() {
|
|
return f.singletonNone;
|
|
}
|
|
fold(e, r) {
|
|
if (this.tag) {
|
|
return r(this.value);
|
|
} else {
|
|
return e();
|
|
}
|
|
}
|
|
isSome() {
|
|
return this.tag;
|
|
}
|
|
isNone() {
|
|
return !this.tag;
|
|
}
|
|
map(e) {
|
|
if (this.tag) {
|
|
return f.some(e(this.value));
|
|
} else {
|
|
return f.none();
|
|
}
|
|
}
|
|
bind(e) {
|
|
if (this.tag) {
|
|
return e(this.value);
|
|
} else {
|
|
return f.none();
|
|
}
|
|
}
|
|
exists(e) {
|
|
return this.tag && e(this.value);
|
|
}
|
|
forall(e) {
|
|
return !this.tag || e(this.value);
|
|
}
|
|
filter(e) {
|
|
if (!this.tag || e(this.value)) {
|
|
return this;
|
|
} else {
|
|
return f.none();
|
|
}
|
|
}
|
|
getOr(e) {
|
|
if (this.tag) {
|
|
return this.value;
|
|
} else {
|
|
return e;
|
|
}
|
|
}
|
|
or(e) {
|
|
if (this.tag) {
|
|
return this;
|
|
} else {
|
|
return e;
|
|
}
|
|
}
|
|
getOrThunk(e) {
|
|
if (this.tag) {
|
|
return this.value;
|
|
} else {
|
|
return e();
|
|
}
|
|
}
|
|
orThunk(e) {
|
|
if (this.tag) {
|
|
return this;
|
|
} else {
|
|
return e();
|
|
}
|
|
}
|
|
getOrDie(e) {
|
|
if (this.tag) {
|
|
return this.value;
|
|
}
|
|
throw new Error(e ?? "Called getOrDie on None");
|
|
}
|
|
static from(e) {
|
|
if (c(e)) {
|
|
return f.some(e);
|
|
} else {
|
|
return f.none();
|
|
}
|
|
}
|
|
getOrNull() {
|
|
if (this.tag) {
|
|
return this.value;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
getOrUndefined() {
|
|
return this.value;
|
|
}
|
|
each(e) {
|
|
if (this.tag) {
|
|
e(this.value);
|
|
}
|
|
}
|
|
toArray() {
|
|
if (this.tag) {
|
|
return [this.value];
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
toString() {
|
|
if (this.tag) {
|
|
return `some(${this.value})`;
|
|
} else {
|
|
return "none()";
|
|
}
|
|
}
|
|
}
|
|
const k = Array.prototype.indexOf;
|
|
const b = Object.keys;
|
|
const w = Object.hasOwnProperty;
|
|
const O = (e, r) => (_(e, r) ? f.from(e[r]) : f.none());
|
|
const _ = (e, r) => w.call(e, r);
|
|
const T = (e) => {
|
|
const r = (r) => r(e);
|
|
const t = g(e);
|
|
const n = () => o;
|
|
const o = {
|
|
tag: true,
|
|
inner: e,
|
|
fold: (r, t) => t(e),
|
|
isValue: v,
|
|
isError: m,
|
|
map: (r) => K.value(r(e)),
|
|
mapError: n,
|
|
bind: r,
|
|
exists: r,
|
|
forall: r,
|
|
getOr: t,
|
|
or: n,
|
|
getOrThunk: t,
|
|
orThunk: n,
|
|
getOrDie: t,
|
|
each: (r) => {
|
|
r(e);
|
|
},
|
|
toOptional: () => f.some(e),
|
|
};
|
|
return o;
|
|
};
|
|
const $ = (e) => {
|
|
const r = () => t;
|
|
const t = {
|
|
tag: false,
|
|
inner: e,
|
|
fold: (r, t) => r(e),
|
|
isValue: m,
|
|
isError: v,
|
|
map: r,
|
|
mapError: (r) => K.error(r(e)),
|
|
bind: r,
|
|
exists: m,
|
|
forall: v,
|
|
getOr: p,
|
|
or: p,
|
|
getOrThunk: h,
|
|
orThunk: h,
|
|
getOrDie:
|
|
((n = String(e)),
|
|
() => {
|
|
throw new Error(n);
|
|
}),
|
|
each: d,
|
|
toOptional: f.none,
|
|
};
|
|
var n;
|
|
return t;
|
|
};
|
|
const K = {
|
|
value: T,
|
|
error: $,
|
|
fromOption: (e, r) => e.fold(() => $(r), T),
|
|
};
|
|
E = (e, r) => (a(e) && a(r) ? j(e, r) : r);
|
|
const j = (...e) => {
|
|
if (e.length === 0) {
|
|
throw new Error("Can't merge zero objects");
|
|
}
|
|
const r = {};
|
|
for (let t = 0; t < e.length; t++) {
|
|
const n = e[t];
|
|
for (const e in n) {
|
|
if (_(n, e)) {
|
|
r[e] = E(r[e], n[e]);
|
|
}
|
|
}
|
|
}
|
|
return r;
|
|
};
|
|
var E;
|
|
const S = (e, r) => {
|
|
const { type: t, message: n } = r;
|
|
e.notificationManager.open({
|
|
type: t,
|
|
text: n,
|
|
});
|
|
};
|
|
const C = (e, r) => {
|
|
const { console: t, editor: n } = r;
|
|
if (c(n)) {
|
|
if (e._skinLoaded) {
|
|
S(e, n);
|
|
} else {
|
|
e.on("SkinLoaded", () => {
|
|
S(e, n);
|
|
});
|
|
}
|
|
}
|
|
if (c(t)) {
|
|
((e) => {
|
|
((e) => {
|
|
switch (e) {
|
|
case "error":
|
|
return console.error;
|
|
case "info":
|
|
return console.info;
|
|
case "warn":
|
|
return console.warn;
|
|
default:
|
|
return console.log;
|
|
}
|
|
})(e.type)(e.message);
|
|
})(t);
|
|
}
|
|
};
|
|
const M = (e) => parseInt(e, 10);
|
|
const x = (e, r) => {
|
|
const t = e - r;
|
|
if (t === 0) {
|
|
return 0;
|
|
} else if (t > 0) {
|
|
return 1;
|
|
} else {
|
|
return -1;
|
|
}
|
|
};
|
|
const P = (e, r, t) => ({
|
|
major: e,
|
|
minor: r,
|
|
patch: t,
|
|
});
|
|
const A = (e) => {
|
|
const r = /([0-9]+)\.([0-9]+)\.([0-9]+)(?:(\-.+)?)/.exec(e);
|
|
if (r) {
|
|
return P(M(r[1]), M(r[2]), M(r[3]));
|
|
} else {
|
|
return P(0, 0, 0);
|
|
}
|
|
};
|
|
const N = (e, r) =>
|
|
!!e &&
|
|
((e, r) => {
|
|
const t = x(e.major, r.major);
|
|
if (t !== 0) {
|
|
return t;
|
|
}
|
|
const n = x(e.minor, r.minor);
|
|
if (n !== 0) {
|
|
return n;
|
|
}
|
|
const o = x(e.patch, r.patch);
|
|
if (o !== 0) {
|
|
return o;
|
|
} else {
|
|
return 0;
|
|
}
|
|
})(
|
|
((e) =>
|
|
A(
|
|
((e) =>
|
|
[e.majorVersion, e.minorVersion]
|
|
.join(".")
|
|
.split(".")
|
|
.slice(0, 3)
|
|
.join("."))(e),
|
|
))(e),
|
|
A(r),
|
|
) === -1;
|
|
const V = A("8.3.0");
|
|
const I = `${V.major}.${V.minor}.0`;
|
|
const U = `${V.major + 1}.0.0`;
|
|
const q = new WeakMap();
|
|
const D = (e) => {};
|
|
const R = (e, r = true) =>
|
|
`${e}${r ? " Read more: https://www.tiny.cloud/docs/tinymce/latest/license-key/" : ""}`;
|
|
const z = (e, r, t, n) => {
|
|
const o = c(n) ? `, status: ${n}` : "";
|
|
if (r === "fallback") {
|
|
C(e, {
|
|
console: {
|
|
type: "warn",
|
|
message: R(
|
|
`The API key could not be validated by the API key validation server [type: ${t}${o}]. Attempting fallback to provided license key.`,
|
|
),
|
|
},
|
|
});
|
|
} else {
|
|
const r =
|
|
"The editor is disabled because the API key could not be validated by the API key validation server";
|
|
C(e, {
|
|
console: {
|
|
type: "error",
|
|
message: R(`${r} [type: ${t}${o}].`),
|
|
},
|
|
editor: {
|
|
type: "warning",
|
|
message: `${r}.`,
|
|
},
|
|
});
|
|
}
|
|
};
|
|
const L = (e) => (r) => r.options.get(e);
|
|
const F = L("license_key");
|
|
const W = L("online_license_key");
|
|
var J;
|
|
(function (e) {
|
|
e[(e.Error = 0)] = "Error";
|
|
e[(e.Value = 1)] = "Value";
|
|
})((J ||= {}));
|
|
const B = (e, r, t) => (e.stype === J.Error ? r(e.serror) : t(e.svalue));
|
|
const G = (e) => ({
|
|
stype: J.Value,
|
|
svalue: e,
|
|
});
|
|
const H = (e) => ({
|
|
stype: J.Error,
|
|
serror: e,
|
|
});
|
|
const Q = B;
|
|
const X = (e, r) =>
|
|
H([
|
|
{
|
|
path: e,
|
|
getErrorInfo: r,
|
|
},
|
|
]);
|
|
const Y = (e) => ({
|
|
extract: (r, t) => {
|
|
o = (e) => ((e, r) => X(e, g(r)))(r, e);
|
|
if ((n = e(t)).stype === J.Error) {
|
|
return o(n.serror);
|
|
} else {
|
|
return n;
|
|
}
|
|
var n;
|
|
var o;
|
|
},
|
|
toString: g("val"),
|
|
});
|
|
const Z = (e, r) =>
|
|
Y((t) => {
|
|
const n = typeof t;
|
|
if (e(t)) {
|
|
return G(t);
|
|
} else {
|
|
return H(`Expected type: ${r} but got: ${n}`);
|
|
}
|
|
});
|
|
const ee = Z(y, "number");
|
|
const re = Z(o, "string");
|
|
const te = Z(i, "boolean");
|
|
const ne = (e, r, t) => {
|
|
switch (e.tag) {
|
|
case "field":
|
|
return r(e.key, e.newKey, e.presence, e.prop);
|
|
case "custom":
|
|
return t(e.newKey, e.instantiator);
|
|
}
|
|
};
|
|
const oe = (e, r, t, n) => n(O(e, r).getOrThunk(() => t(e)));
|
|
const se = (e, r, t, n, o) => {
|
|
const a = (e) => o.extract(r.concat([n]), e);
|
|
const i = (e) =>
|
|
e.fold(
|
|
() => G(f.none()),
|
|
(e) => {
|
|
t = o.extract(r.concat([n]), e);
|
|
s = f.some;
|
|
if (t.stype === J.Value) {
|
|
return {
|
|
stype: J.Value,
|
|
svalue: s(t.svalue),
|
|
};
|
|
} else {
|
|
return t;
|
|
}
|
|
var t;
|
|
var s;
|
|
},
|
|
);
|
|
switch (e.tag) {
|
|
case "required":
|
|
return ((e, r, t, n) =>
|
|
O(r, t).fold(
|
|
() =>
|
|
((e, r, t) =>
|
|
X(e, () => {
|
|
return (
|
|
'Could not find valid *required* value for "' +
|
|
r +
|
|
'" in ' +
|
|
(s((e = t)) && b(e).length > 100
|
|
? " removed due to size"
|
|
: JSON.stringify(e, null, 2))
|
|
);
|
|
var e;
|
|
}))(e, t, r),
|
|
n,
|
|
))(r, t, n, a);
|
|
case "defaultedThunk":
|
|
return oe(t, n, e.process, a);
|
|
case "option":
|
|
return ((e, r, t) => t(O(e, r)))(t, n, i);
|
|
case "defaultedOptionThunk":
|
|
return ((e, r, t, n) => n(O(e, r).map((r) => (r === true ? t(e) : r))))(
|
|
t,
|
|
n,
|
|
e.process,
|
|
i,
|
|
);
|
|
case "mergeWithThunk":
|
|
return oe(t, n, g({}), (r) => {
|
|
const n = j(e.process(t), r);
|
|
return a(n);
|
|
});
|
|
}
|
|
};
|
|
const ae = (e) => ({
|
|
extract: (r, t) =>
|
|
((e, r, t) => {
|
|
const n = {};
|
|
const o = [];
|
|
for (const s of t) {
|
|
ne(
|
|
s,
|
|
(t, s, a, i) => {
|
|
const l = se(a, e, r, t, i);
|
|
Q(
|
|
l,
|
|
(e) => {
|
|
o.push(...e);
|
|
},
|
|
(e) => {
|
|
n[s] = e;
|
|
},
|
|
);
|
|
},
|
|
(e, t) => {
|
|
n[e] = t(r);
|
|
},
|
|
);
|
|
}
|
|
if (o.length > 0) {
|
|
return H(o);
|
|
} else {
|
|
return G(n);
|
|
}
|
|
})(r, t, e),
|
|
toString: () => {
|
|
const r = ((e, r) => {
|
|
const t = e.length;
|
|
const n = new Array(t);
|
|
for (let o = 0; o < t; o++) {
|
|
const t = e[o];
|
|
n[o] = r(t);
|
|
}
|
|
return n;
|
|
})(e, (e) =>
|
|
ne(
|
|
e,
|
|
(e, r, t, n) => e + " -> " + n.toString(),
|
|
(e, r) => "state(" + e + ")",
|
|
),
|
|
);
|
|
return "obj{\n" + r.join("\n") + "}";
|
|
},
|
|
});
|
|
const ie = (e, r, t) => {
|
|
n = ((e, r, t) =>
|
|
((e) =>
|
|
e.stype === J.Error
|
|
? {
|
|
stype: J.Error,
|
|
serror: ((e) => ({
|
|
input: t,
|
|
errors: e,
|
|
}))(e.serror),
|
|
}
|
|
: e)(r.extract([e], t)))(e, r, t);
|
|
return B(n, K.error, K.value);
|
|
var n;
|
|
};
|
|
const le = (e, r, t, n) => ({
|
|
tag: "field",
|
|
key: e,
|
|
newKey: r,
|
|
presence: t,
|
|
prop: n,
|
|
});
|
|
const ce = (e, r) =>
|
|
le(
|
|
e,
|
|
e,
|
|
{
|
|
tag: "required",
|
|
process: {},
|
|
},
|
|
r,
|
|
);
|
|
const ue = (e) => ce(e, re);
|
|
const ye = (e) => ce(e, te);
|
|
const de = (e, r) =>
|
|
((e, r) =>
|
|
le(
|
|
e,
|
|
e,
|
|
{
|
|
tag: "option",
|
|
process: {},
|
|
},
|
|
r,
|
|
))(e, ae(r));
|
|
const ge = (e, r, t) =>
|
|
((e, r, t) =>
|
|
le(
|
|
e,
|
|
e,
|
|
((e) => ({
|
|
tag: "defaultedThunk",
|
|
process: g(e),
|
|
}))(r),
|
|
t,
|
|
))(
|
|
e,
|
|
r,
|
|
((e) => {
|
|
r = (r) => {
|
|
t = e;
|
|
n = r;
|
|
if (k.call(t, n) > -1) {
|
|
return K.value(r);
|
|
} else {
|
|
return K.error(
|
|
`Unsupported value: "${r}", choose one of "${e.join(", ")}".`,
|
|
);
|
|
}
|
|
var t;
|
|
var n;
|
|
};
|
|
return Y((e) => r(e).fold(H, G));
|
|
var r;
|
|
})(t),
|
|
);
|
|
const pe = [
|
|
de("console", [
|
|
ge("type", "warn", ["error", "warn", "log", "info"]),
|
|
ue("message"),
|
|
]),
|
|
de("editor", [
|
|
ge("type", "warning", ["error", "warning", "info", "success"]),
|
|
ue("message"),
|
|
]),
|
|
];
|
|
const he = [ye("ok"), ue("id"), ue("key"), de("message", pe)];
|
|
const me = [ye("ok"), ce("status", ee), ue("name"), de("message", pe)];
|
|
var ve;
|
|
var fe;
|
|
var ke;
|
|
(ke = ve ||= {}).Timeout = "get_license_online_timeout_error";
|
|
ke.Missing = "get_license_online_missing_error";
|
|
ke.ParseResponse = "get_license_online_parse_response_error";
|
|
ke.Invalid = "get_license_online_invalid_error";
|
|
ke.Server = "get_license_online_server_error";
|
|
ke.Unknown = "get_license_online_unknown_error";
|
|
(fe ||= {}).NoKeySpecified = "get_license_no_key_specified";
|
|
const be = async (e, r, t, n = 30000) => {
|
|
const o = (r, n, o) =>
|
|
t.fold(
|
|
() => {
|
|
z(e, "readonly", n, o);
|
|
return K.error({
|
|
type: n,
|
|
});
|
|
},
|
|
(t) => {
|
|
z(e, r, n, o);
|
|
if (r === "readonly") {
|
|
return K.error({
|
|
type: n,
|
|
});
|
|
} else {
|
|
return K.value(t);
|
|
}
|
|
},
|
|
);
|
|
a = r.then(
|
|
(r) =>
|
|
((e) => {
|
|
const r = s(e) && e.ok === true ? he : me;
|
|
return ie("onlicenseKeyResult", ae(r), e);
|
|
})(r)
|
|
.mapError((r) => {
|
|
z(e, "readonly", ve.ParseResponse);
|
|
return {
|
|
type: ve.ParseResponse,
|
|
};
|
|
})
|
|
.bind((r) => {
|
|
if (r.ok) {
|
|
r.message
|
|
.map((e) => ({
|
|
console: e.console.getOrUndefined(),
|
|
editor: e.editor.getOrUndefined(),
|
|
}))
|
|
.each((r) => {
|
|
C(e, r);
|
|
});
|
|
return K.value(r.key);
|
|
}
|
|
{
|
|
const t = r.status >= 400 && r.status < 500;
|
|
const n = t ? ve.Invalid : ve.Server;
|
|
r.message
|
|
.map((e) => ({
|
|
console: e.console.getOrUndefined(),
|
|
editor: e.editor.getOrUndefined(),
|
|
}))
|
|
.each((r) => {
|
|
C(e, r);
|
|
});
|
|
return o(t ? "readonly" : "fallback", n, r.status);
|
|
}
|
|
}),
|
|
(r) => {
|
|
if (c(r)) {
|
|
try {
|
|
C(e, {
|
|
console: {
|
|
type: "error",
|
|
message: String(r),
|
|
},
|
|
});
|
|
} catch (e) {}
|
|
}
|
|
const t = ve.Unknown;
|
|
return o("fallback", t);
|
|
},
|
|
);
|
|
i = n;
|
|
l = () => {
|
|
const e = ve.Timeout;
|
|
return o("fallback", e);
|
|
};
|
|
return new Promise((e, r) => {
|
|
const t = setTimeout(() => e(l()), i);
|
|
a.then(e, r).finally(() => {
|
|
clearTimeout(t);
|
|
});
|
|
});
|
|
var a;
|
|
var i;
|
|
var l;
|
|
};
|
|
const we = async (e, r) => {
|
|
const t = ((e) => {
|
|
const { configKey: r, onlineKey: t } = e;
|
|
if (l(t)) {
|
|
if (l(r)) {
|
|
return {
|
|
type: "reportNoKey",
|
|
};
|
|
} else {
|
|
return {
|
|
type: "useConfigKey",
|
|
key: r,
|
|
};
|
|
}
|
|
} else if (l(r)) {
|
|
return {
|
|
type: "useOnlineKey",
|
|
key: t,
|
|
};
|
|
} else {
|
|
return {
|
|
type: "tryOnlineKeyPossibleFallback",
|
|
configKey: r,
|
|
onlineKey: t,
|
|
};
|
|
}
|
|
})({
|
|
configKey: F(e),
|
|
onlineKey: W(e),
|
|
});
|
|
switch (t.type) {
|
|
case "reportNoKey":
|
|
((e) => {
|
|
const r =
|
|
"The editor is disabled because a TinyMCE license key has not been provided";
|
|
C(e, {
|
|
console: {
|
|
type: "error",
|
|
message: R(
|
|
`${r}. Make sure to provide a valid license key or add license_key: 'gpl' to the init config to agree to the open source license terms.`,
|
|
),
|
|
},
|
|
editor: {
|
|
type: "warning",
|
|
message: `${r}.`,
|
|
},
|
|
});
|
|
})(e);
|
|
return K.error({
|
|
type: fe.NoKeySpecified,
|
|
});
|
|
case "useConfigKey": {
|
|
const { key: e } = t;
|
|
return K.value(e);
|
|
}
|
|
case "useOnlineKey": {
|
|
const { key: n } = t;
|
|
return be(e, n, f.none(), r);
|
|
}
|
|
case "tryOnlineKeyPossibleFallback": {
|
|
const { onlineKey: n, configKey: o } = t;
|
|
return be(e, n, f.some(o), r);
|
|
}
|
|
}
|
|
};
|
|
const Oe = (e, r) => {
|
|
const t = ((e) => {
|
|
let r;
|
|
let t = false;
|
|
return (...n) => {
|
|
if (!t) {
|
|
t = true;
|
|
// r = e.apply(null, n);
|
|
}
|
|
return r;
|
|
};
|
|
})(we);
|
|
a = e;
|
|
const n = {
|
|
validate: async () => D(a),
|
|
};
|
|
var a;
|
|
const i = ((e) => {
|
|
let r = false;
|
|
return {
|
|
validate: async (t, n) => {},
|
|
};
|
|
})(e);
|
|
const l = (async (e, r) => {
|
|
try {
|
|
return await (async (e, r) => {
|
|
const t = `${r}/js/commerciallicensekeymanager${e.suffix}.js`;
|
|
var n;
|
|
return (
|
|
await ((n = t),
|
|
tinymce.Resource.load("licensekeymanager.6nle0b3ulk", n))
|
|
)(e);
|
|
})(e, r);
|
|
} catch (r) {
|
|
console.error(r);
|
|
((e) => {
|
|
const r =
|
|
"The editor is disabled because the TinyMCE license key could not be validated";
|
|
C(e, {
|
|
console: {
|
|
type: "error",
|
|
message: R(
|
|
`${r}. The TinyMCE Commercial License Key Manager plugin was unable to load additional required resources.`,
|
|
),
|
|
},
|
|
editor: {
|
|
type: "warning",
|
|
message: `${r}.`,
|
|
},
|
|
});
|
|
})(e);
|
|
return {
|
|
validate: async () => D(e),
|
|
};
|
|
}
|
|
})(e, r);
|
|
return Object.freeze({
|
|
validate: Object.freeze(async (r) => {
|
|
return true;
|
|
}),
|
|
});
|
|
};
|
|
var _e;
|
|
var Te;
|
|
_e = tinymce;
|
|
Te = "licensekeymanager";
|
|
if (
|
|
N(_e, I)
|
|
? (console.error(
|
|
`The "${Te}" plugin requires at least version ${I} of TinyMCE.`,
|
|
),
|
|
0)
|
|
: N(_e, U) ||
|
|
(console.error(
|
|
`The "${Te}" plugin requires at least version ${I} of TinyMCE but less than ${U}.`,
|
|
),
|
|
0)
|
|
) {
|
|
tinymce._addLicenseKeyManager((e, r) => {
|
|
var t;
|
|
(0, (t = e).options.register)("online_license_key", {
|
|
processor: (e) => {
|
|
// if (u(e)) {
|
|
// const n = e(t);
|
|
// if (s((r = n)) && u(r.then) && u(r.catch)) {
|
|
// return {
|
|
// valid: true,
|
|
// value: n,
|
|
// };
|
|
// }
|
|
// } else if (l(e)) {
|
|
// return {
|
|
// valid: true,
|
|
// value: undefined,
|
|
// };
|
|
// }
|
|
return {
|
|
valid: true,
|
|
value: Promise.resolve({
|
|
created: "2025-12-13T03:01:00.306Z",
|
|
owner: {
|
|
tag: "cloud",
|
|
apiKey: "qagffr3pkuv17a8on1afax661irst1hbr4e6tbv888sz91jc",
|
|
},
|
|
id: "019b15a7-8b12-74f3-8163-90c63bd99adb",
|
|
key: "T8LK:eyJhbGciOiJFUzI1NiIsIng1YyI6WyJNSUlCbURDQ0FUMmdBd0lCQWdJVWJTS2NpUDJROHBNTFJTc29JS29ucUNXYmw1VXdDZ1lJS29aSXpqMEVBd0l3UHpFYU1CZ0dBMVVFQ2d3UlZHbHVlU0JVWldOb2JtOXNiMmRwWlhNeElUQWZCZ05WQkFNTUdGUnBibmxOUTBVZ09DQnNhV05sYm5ObElHdGxlU0JEUVRBZ0Z3MHlOVEEwTVRBd05ESTJNVEJhR0E4eU1EYzFNREV3TVRBME1qWXhNRm93RWpFUU1BNEdBMVVFQXd3SFZEaE1TMU10VURCWk1CTUdCeXFHU000OUFnRUdDQ3FHU000OUF3RUhBMElBQkdnTjlqUG5Ga2o1Q0VSbEJDUkNMNGliOXBDMUo5U3p4ajBmckU1QkgxdE8yaEZYQmlNd2VlRjFheEh6cjBEcnhycUE0dDNFbTJZaUYyekk4ZVFoa2dHalFqQkFNQjBHQTFVZERnUVdCQlE0dU42blREemN1YmlHMXVET3Q4OUlQMkFWQlRBZkJnTlZIU01FR0RBV2dCVHFoanNsN0lWdEZFYVMvaFNSUXhiT2ZuaWFRVEFLQmdncWhrak9QUVFEQWdOSkFEQkdBaUVBMmtHTmVZRnRranYvemFzUEVKWjBQVFZTOW1KdTFaRWYvWklQTGFFSDJ6MENJUURRTnFBL0FFTVFlQno2T0VHNlBteVhFakJVZDVqRDBxcVlwVS9pM1hhL2VRPT0iXX0.CiQwMTliMTVhNy04YjEyLTc0ZjMtODE2My05MGM2M2JkOTlhZGLCAhAKDAjs0PjJBhCA4fSRARIAkgMkNzdhMTViNTAtMjU5OS00OGIzLWI0MzktMTE2OGEwN2EwOWJk4gMkMmViMmU5MGMtOTM2YS00MDAyLTk2YzQtMDMwNGQ1MWFlNTg4sAQIggUEEgIIA9IFIgIDBAUGFgcICQoLDA0ODyMQERITFBUXGBkaGx8iHB0eICGiBhgKFmh0dHBzOi8vd3d3LnRpbnkuY2xvdWQ.70VFxHueBe2uJTsKcj3F6Ny_axE7kg-ywGRBGNJotlN4XNePbAW1vmYDotSGZorjoVIf0l5GBGMtca5W1H-Spw",
|
|
}),
|
|
};
|
|
},
|
|
});
|
|
const n = Oe(e, r);
|
|
return n;
|
|
});
|
|
}
|
|
})();
|