@xpadev-net/niconicomments
Version:
NiconiComments is a comment drawing library that is somewhat compatible with the official Nico Nico Douga player.
1,491 lines (1,437 loc) • 188 kB
JavaScript
/*!
niconicomments.js v0.2.76
(c) 2021 xpadev-net https://xpadev.net
Released under the MIT License.
*/
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.NiconiComments = factory());
})(this, (function () { 'use strict';
let imageCache = {};
const resetImageCache = () => {
imageCache = {};
};
let nicoScripts = {
reverse: [],
default: [],
replace: [],
ban: [],
seekDisable: [],
jump: [],
};
const resetNicoScripts = () => {
nicoScripts = {
reverse: [],
default: [],
replace: [],
ban: [],
seekDisable: [],
jump: [],
};
};
let plugins = [];
const setPlugins = (input) => {
plugins = input;
};
var index$4 = /*#__PURE__*/Object.freeze({
__proto__: null,
get imageCache () { return imageCache; },
get nicoScripts () { return nicoScripts; },
get plugins () { return plugins; },
resetImageCache: resetImageCache,
resetNicoScripts: resetNicoScripts,
setPlugins: setPlugins
});
let isDebug = false;
const setIsDebug = (val) => {
isDebug = val;
};
let defaultConfig;
const updateConfig = (config) => {
defaultConfig = config;
};
const defaultOptions = {
config: {},
debug: false,
enableLegacyPiP: false,
format: "default",
formatted: false,
keepCA: false,
mode: "default",
scale: 1,
showCollision: false,
showCommentCount: false,
showFPS: false,
useLegacy: false,
video: undefined,
lazy: false,
};
let config;
let options;
const setConfig = (value) => {
config = value;
};
const setOptions = (value) => {
options = value;
};
var config$1 = /*#__PURE__*/Object.freeze({
__proto__: null,
get config () { return config; },
get defaultConfig () { return defaultConfig; },
defaultOptions: defaultOptions,
get options () { return options; },
setConfig: setConfig,
setOptions: setOptions,
updateConfig: updateConfig
});
class CanvasRenderingContext2DError extends Error {
constructor(options = {}) {
super("CanvasRenderingContext2DError", options);
}
}
CanvasRenderingContext2DError.prototype.name = "CanvasRenderingContext2DError";
class InvalidFormatError extends Error {
constructor(options = {}) {
super("InvalidFormatError", options);
}
}
InvalidFormatError.prototype.name = "InvalidFormatError";
class InvalidOptionError extends Error {
constructor(options = {}) {
super("Invalid option\nPlease check document: https://xpadev-net.github.io/niconicomments/#p_options", options);
}
}
InvalidOptionError.prototype.name = "InvalidOptionError";
class NotImplementedError extends Error {
pluginName;
methodName;
constructor(pluginName, methodName, options = {}) {
super("NotImplementedError", options);
this.pluginName = pluginName;
this.methodName = methodName;
}
}
NotImplementedError.prototype.name = "NotImplementedError";
var index$3 = /*#__PURE__*/Object.freeze({
__proto__: null,
CanvasRenderingContext2DError: CanvasRenderingContext2DError,
InvalidFormatError: InvalidFormatError,
InvalidOptionError: InvalidOptionError,
NotImplementedError: NotImplementedError
});
const arrayPush = (_array, key, push) => {
let array = _array;
if (!array) {
array = {};
}
if (!array[Number(key)]) {
array[Number(key)] = [];
}
array[Number(key)]?.push(push);
};
const arrayEqual = (a, b) => {
if (a.length !== b.length)
return false;
for (let i = 0, n = a.length; i < n; ++i) {
if (a[i] !== b[i])
return false;
}
return true;
};
const hex2rgb = (_hex) => {
let hex = _hex;
if (hex.startsWith("#"))
hex = hex.slice(1);
if (hex.length === 3)
hex =
hex.slice(0, 1) +
hex.slice(0, 1) +
hex.slice(1, 2) +
hex.slice(1, 2) +
hex.slice(2, 3) +
hex.slice(2, 3);
return [hex.slice(0, 2), hex.slice(2, 4), hex.slice(4, 6)].map((str) => Number.parseInt(str, 16));
};
const hex2rgba = (_hex) => {
let hex = _hex;
if (hex.startsWith("#"))
hex = hex.slice(1);
if (hex.length === 4)
hex =
hex.slice(0, 1) +
hex.slice(0, 1) +
hex.slice(1, 2) +
hex.slice(1, 2) +
hex.slice(2, 3) +
hex.slice(2, 3) +
hex.slice(3, 4) +
hex.slice(3, 4);
return [
hex.slice(0, 2),
hex.slice(2, 4),
hex.slice(4, 6),
hex.slice(4, 6),
].map((str, index) => {
if (index === 3)
return Number.parseInt(str, 16) / 256;
return Number.parseInt(str, 16);
});
};
const getStrokeColor = (comment) => {
if (comment.strokeColor) {
const color = comment.strokeColor.slice(1);
const length = color.length;
if (length === 3 || length === 6) {
return `rgba(${hex2rgb(color).join(",")},${config.contextStrokeOpacity})`;
}
if (length === 4 || length === 8) {
return `rgba(${hex2rgba(color).join(",")})`;
}
}
return `rgba(${hex2rgb(comment.color === "#000000"
? config.contextStrokeInversionColor
: config.contextStrokeColor).join(",")},${config.contextStrokeOpacity})`;
};
function _arrayLikeToArray(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
return n;
}
function _arrayWithoutHoles(r) {
if (Array.isArray(r)) return _arrayLikeToArray(r);
}
function _assertThisInitialized(e) {
if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
return e;
}
function _callSuper(t, o, e) {
return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
}
function _classCallCheck(a, n) {
if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
}
function _construct(t, e, r) {
if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
var o = [null];
o.push.apply(o, e);
var p = new (t.bind.apply(t, o))();
return r && _setPrototypeOf(p, r.prototype), p;
}
function _createClass(e, r, t) {
return Object.defineProperty(e, "prototype", {
writable: false
}), e;
}
function _createForOfIteratorHelper(r, e) {
var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (!t) {
if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
t && (r = t);
var n = 0,
F = function () {};
return {
s: F,
n: function () {
return n >= r.length ? {
done: true
} : {
done: false,
value: r[n++]
};
},
e: function (r) {
throw r;
},
f: F
};
}
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
var o,
a = true,
u = false;
return {
s: function () {
t = t.call(r);
},
n: function () {
var r = t.next();
return a = r.done, r;
},
e: function (r) {
u = true, o = r;
},
f: function () {
try {
a || null == t.return || t.return();
} finally {
if (u) throw o;
}
}
};
}
function _defineProperty(e, r, t) {
return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
value: t,
enumerable: true,
configurable: true,
writable: true
}) : e[r] = t, e;
}
function _getPrototypeOf(t) {
return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
}, _getPrototypeOf(t);
}
function _inherits(t, e) {
if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
t.prototype = Object.create(e && e.prototype, {
constructor: {
value: t,
writable: true,
configurable: true
}
}), Object.defineProperty(t, "prototype", {
writable: false
}), e && _setPrototypeOf(t, e);
}
function _isNativeFunction(t) {
try {
return -1 !== Function.toString.call(t).indexOf("[native code]");
} catch (n) {
return "function" == typeof t;
}
}
function _isNativeReflectConstruct() {
try {
var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
} catch (t) {}
return (_isNativeReflectConstruct = function () {
return !!t;
})();
}
function _iterableToArray(r) {
if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function ownKeys(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function (r) {
return Object.getOwnPropertyDescriptor(e, r).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread2(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
_defineProperty(e, r, t[r]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
});
}
return e;
}
function _possibleConstructorReturn(t, e) {
if (e && ("object" == typeof e || "function" == typeof e)) return e;
if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
return _assertThisInitialized(t);
}
function _setPrototypeOf(t, e) {
return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
return t.__proto__ = e, t;
}, _setPrototypeOf(t, e);
}
function _toConsumableArray(r) {
return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
}
function _toPrimitive(t, r) {
if ("object" != typeof t || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r);
if ("object" != typeof i) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == typeof i ? i : i + "";
}
function _typeof(o) {
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
return typeof o;
} : function (o) {
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
}, _typeof(o);
}
function _unsupportedIterableToArray(r, a) {
if (r) {
if ("string" == typeof r) return _arrayLikeToArray(r, a);
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
}
}
function _wrapNativeSuper(t) {
var r = "function" == typeof Map ? new Map() : void 0;
return _wrapNativeSuper = function (t) {
if (null === t || !_isNativeFunction(t)) return t;
if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
if (void 0 !== r) {
if (r.has(t)) return r.get(t);
r.set(t, Wrapper);
}
function Wrapper() {
return _construct(t, arguments, _getPrototypeOf(this).constructor);
}
return Wrapper.prototype = Object.create(t.prototype, {
constructor: {
value: Wrapper,
enumerable: false,
writable: true,
configurable: true
}
}), _setPrototypeOf(Wrapper, t);
}, _wrapNativeSuper(t);
}
// src/storages/globalConfig/globalConfig.ts
var store;
// @__NO_SIDE_EFFECTS__
function getGlobalConfig(config2) {
var _config2$lang, _store, _config2$abortEarly, _store2, _config2$abortPipeEar, _store3;
return {
lang: (_config2$lang = void 0 ) !== null && _config2$lang !== void 0 ? _config2$lang : (_store = store) === null || _store === void 0 ? void 0 : _store.lang,
message: config2 === null || config2 === void 0 ? void 0 : config2.message,
abortEarly: (_config2$abortEarly = void 0 ) !== null && _config2$abortEarly !== void 0 ? _config2$abortEarly : (_store2 = store) === null || _store2 === void 0 ? void 0 : _store2.abortEarly,
abortPipeEarly: (_config2$abortPipeEar = void 0 ) !== null && _config2$abortPipeEar !== void 0 ? _config2$abortPipeEar : (_store3 = store) === null || _store3 === void 0 ? void 0 : _store3.abortPipeEarly
};
}
// src/storages/globalMessage/globalMessage.ts
var store2;
// @__NO_SIDE_EFFECTS__
function getGlobalMessage(lang) {
var _store4;
return (_store4 = store2) === null || _store4 === void 0 ? void 0 : _store4.get(lang);
}
// src/storages/schemaMessage/schemaMessage.ts
var store3;
// @__NO_SIDE_EFFECTS__
function getSchemaMessage(lang) {
var _store6;
return (_store6 = store3) === null || _store6 === void 0 ? void 0 : _store6.get(lang);
}
// src/storages/specificMessage/specificMessage.ts
var store4;
// @__NO_SIDE_EFFECTS__
function getSpecificMessage(reference, lang) {
var _store8;
return (_store8 = store4) === null || _store8 === void 0 || (_store8 = _store8.get(reference)) === null || _store8 === void 0 ? void 0 : _store8.get(lang);
}
// src/utils/_stringify/_stringify.ts
// @__NO_SIDE_EFFECTS__
function _stringify(input) {
var type = _typeof(input);
if (type === "string") {
return "\"".concat(input, "\"");
}
if (type === "number" || type === "bigint" || type === "boolean") {
return "".concat(input);
}
if (type === "object" || type === "function") {
var _ref, _Object$getPrototypeO;
return (_ref = input && ((_Object$getPrototypeO = Object.getPrototypeOf(input)) === null || _Object$getPrototypeO === void 0 || (_Object$getPrototypeO = _Object$getPrototypeO.constructor) === null || _Object$getPrototypeO === void 0 ? void 0 : _Object$getPrototypeO.name)) !== null && _ref !== void 0 ? _ref : "null";
}
return type;
}
// src/utils/_addIssue/_addIssue.ts
function _addIssue(context, label, dataset, config2, other) {
var _ref2, _other$expected, _other$received, _ref3, _ref4, _ref5, _ref6, _other$message;
var input = other && "input" in other ? other.input : dataset.value;
var expected = (_ref2 = (_other$expected = other === null || other === void 0 ? void 0 : other.expected) !== null && _other$expected !== void 0 ? _other$expected : context.expects) !== null && _ref2 !== void 0 ? _ref2 : null;
var received = (_other$received = other === null || other === void 0 ? void 0 : other.received) !== null && _other$received !== void 0 ? _other$received : _stringify(input);
var issue = {
kind: context.kind,
type: context.type,
input: input,
expected: expected,
received: received,
message: "Invalid ".concat(label, ": ").concat(expected ? "Expected ".concat(expected, " but r") : "R", "eceived ").concat(received),
requirement: context.requirement,
path: other === null || other === void 0 ? void 0 : other.path,
issues: other === null || other === void 0 ? void 0 : other.issues,
lang: config2.lang,
abortEarly: config2.abortEarly,
abortPipeEarly: config2.abortPipeEarly
};
var isSchema = context.kind === "schema";
var message2 = (_ref3 = (_ref4 = (_ref5 = (_ref6 = (_other$message = other === null || other === void 0 ? void 0 : other.message) !== null && _other$message !== void 0 ? _other$message : context.message) !== null && _ref6 !== void 0 ? _ref6 : getSpecificMessage(context.reference, issue.lang)) !== null && _ref5 !== void 0 ? _ref5 : isSchema ? getSchemaMessage(issue.lang) : null) !== null && _ref4 !== void 0 ? _ref4 : config2.message) !== null && _ref3 !== void 0 ? _ref3 : getGlobalMessage(issue.lang);
if (message2 !== void 0) {
issue.message = typeof message2 === "function" ?
// @ts-expect-error
message2(issue) : message2;
}
if (isSchema) {
dataset.typed = false;
}
if (dataset.issues) {
dataset.issues.push(issue);
} else {
dataset.issues = [issue];
}
}
// src/utils/_getStandardProps/_getStandardProps.ts
// @__NO_SIDE_EFFECTS__
function _getStandardProps(context) {
return {
version: 1,
vendor: "valibot",
validate: function validate(value2) {
return context["~run"]({
value: value2
}, getGlobalConfig());
}
};
}
// src/utils/_isValidObjectKey/_isValidObjectKey.ts
// @__NO_SIDE_EFFECTS__
function _isValidObjectKey(object2, key) {
return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
}
// src/utils/_joinExpects/_joinExpects.ts
// @__NO_SIDE_EFFECTS__
function _joinExpects(values2, separator) {
var _list$;
var list = _toConsumableArray(new Set(values2));
if (list.length > 1) {
return "(".concat(list.join(" ".concat(separator, " ")), ")");
}
return (_list$ = list[0]) !== null && _list$ !== void 0 ? _list$ : "never";
}
// src/utils/ValiError/ValiError.ts
var ValiError = /*#__PURE__*/function (_Error) {
/**
* Creates a Valibot error with useful information.
*
* @param issues The error issues.
*/
function ValiError(issues) {
var _this;
_classCallCheck(this, ValiError);
_this = _callSuper(this, ValiError, [issues[0].message]);
_this.name = "ValiError";
_this.issues = issues;
return _this;
}
_inherits(ValiError, _Error);
return _createClass(ValiError);
}(/*#__PURE__*/_wrapNativeSuper(Error));
// src/actions/check/check.ts
// @__NO_SIDE_EFFECTS__
function check(requirement, message2) {
return {
kind: "validation",
type: "check",
reference: check,
async: false,
expects: null,
requirement: requirement,
message: message2,
"~run": function run(dataset, config2) {
if (dataset.typed && !this.requirement(dataset.value)) {
_addIssue(this, "input", dataset, config2);
}
return dataset;
}
};
}
// src/actions/notValue/notValue.ts
// @__NO_SIDE_EFFECTS__
function notValue(requirement, message2) {
return {
kind: "validation",
type: "not_value",
reference: notValue,
async: false,
expects: requirement instanceof Date ? "!".concat(requirement.toJSON()) : "!".concat(_stringify(requirement)),
requirement: requirement,
message: message2,
"~run": function run(dataset, config2) {
if (dataset.typed && this.requirement <= dataset.value && this.requirement >= dataset.value) {
_addIssue(this, "value", dataset, config2, {
received: dataset.value instanceof Date ? dataset.value.toJSON() : _stringify(dataset.value)
});
}
return dataset;
}
};
}
// src/actions/regex/regex.ts
// @__NO_SIDE_EFFECTS__
function regex(requirement, message2) {
return {
kind: "validation",
type: "regex",
reference: regex,
async: false,
expects: "".concat(requirement),
requirement: requirement,
message: message2,
"~run": function run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "format", dataset, config2);
}
return dataset;
}
};
}
// src/methods/getFallback/getFallback.ts
// @__NO_SIDE_EFFECTS__
function getFallback(schema, dataset, config2) {
return typeof schema.fallback === "function" ?
// @ts-expect-error
schema.fallback(dataset, config2) :
// @ts-expect-error
schema.fallback;
}
// src/methods/getDefault/getDefault.ts
// @__NO_SIDE_EFFECTS__
function getDefault(schema, dataset, config2) {
return typeof schema["default"] === "function" ?
// @ts-expect-error
schema["default"](dataset, config2) :
// @ts-expect-error
schema["default"];
}
// src/methods/is/is.ts
// @__NO_SIDE_EFFECTS__
function is(schema, input) {
return !schema["~run"]({
value: input
}, {
abortEarly: true
}).issues;
}
// src/schemas/array/array.ts
// @__NO_SIDE_EFFECTS__
function array(item, message2) {
return {
kind: "schema",
type: "array",
reference: array,
expects: "Array",
async: false,
item: item,
message: message2,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
var input = dataset.value;
if (Array.isArray(input)) {
dataset.typed = true;
dataset.value = [];
for (var key = 0; key < input.length; key++) {
var value2 = input[key];
var itemDataset = this.item["~run"]({
value: value2
}, config2);
if (itemDataset.issues) {
var pathItem = {
type: "array",
origin: "value",
input: input,
key: key,
value: value2
};
var _iterator12 = _createForOfIteratorHelper(itemDataset.issues),
_step12;
try {
for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
var _dataset$issues;
var issue = _step12.value;
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
(_dataset$issues = dataset.issues) === null || _dataset$issues === void 0 || _dataset$issues.push(issue);
}
} catch (err) {
_iterator12.e(err);
} finally {
_iterator12.f();
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/boolean/boolean.ts
// @__NO_SIDE_EFFECTS__
function _boolean(message2) {
return {
kind: "schema",
type: "boolean",
reference: _boolean,
expects: "boolean",
async: false,
message: message2,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
if (typeof dataset.value === "boolean") {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/instance/instance.ts
// @__NO_SIDE_EFFECTS__
function instance(class_, message2) {
return {
kind: "schema",
type: "instance",
reference: instance,
expects: class_.name,
async: false,
"class": class_,
message: message2,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
if (dataset.value instanceof this["class"]) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/intersect/utils/_merge/_merge.ts
// @__NO_SIDE_EFFECTS__
function _merge(value1, value2) {
if (_typeof(value1) === _typeof(value2)) {
if (value1 === value2 || value1 instanceof Date && value2 instanceof Date && +value1 === +value2) {
return {
value: value1
};
}
if (value1 && value2 && value1.constructor === Object && value2.constructor === Object) {
for (var key in value2) {
if (key in value1) {
var dataset = /* @__PURE__ */_merge(value1[key], value2[key]);
if (dataset.issue) {
return dataset;
}
value1[key] = dataset.value;
} else {
value1[key] = value2[key];
}
}
return {
value: value1
};
}
if (Array.isArray(value1) && Array.isArray(value2)) {
if (value1.length === value2.length) {
for (var index = 0; index < value1.length; index++) {
var _dataset = /* @__PURE__ */_merge(value1[index], value2[index]);
if (_dataset.issue) {
return _dataset;
}
value1[index] = _dataset.value;
}
return {
value: value1
};
}
}
}
return {
issue: true
};
}
// src/schemas/intersect/intersect.ts
// @__NO_SIDE_EFFECTS__
function intersect(options, message2) {
return {
kind: "schema",
type: "intersect",
reference: intersect,
expects: _joinExpects(options.map(function (option) {
return option.expects;
}), "&"),
async: false,
options: options,
message: message2,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
if (this.options.length) {
var input = dataset.value;
var outputs;
dataset.typed = true;
var _iterator14 = _createForOfIteratorHelper(this.options),
_step14;
try {
for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
var schema = _step14.value;
var optionDataset = schema["~run"]({
value: input
}, config2);
if (optionDataset.issues) {
if (dataset.issues) {
var _dataset$issues3;
(_dataset$issues3 = dataset.issues).push.apply(_dataset$issues3, _toConsumableArray(optionDataset.issues));
} else {
dataset.issues = optionDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!optionDataset.typed) {
dataset.typed = false;
}
if (dataset.typed) {
if (outputs) {
outputs.push(optionDataset.value);
} else {
outputs = [optionDataset.value];
}
}
}
} catch (err) {
_iterator14.e(err);
} finally {
_iterator14.f();
}
if (dataset.typed) {
dataset.value = outputs[0];
for (var index = 1; index < outputs.length; index++) {
var mergeDataset = _merge(dataset.value, outputs[index]);
if (mergeDataset.issue) {
_addIssue(this, "type", dataset, config2, {
received: "unknown"
});
break;
}
dataset.value = mergeDataset.value;
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/literal/literal.ts
// @__NO_SIDE_EFFECTS__
function literal(literal_, message2) {
return {
kind: "schema",
type: "literal",
reference: literal,
expects: _stringify(literal_),
async: false,
literal: literal_,
message: message2,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
if (dataset.value === this.literal) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/nullable/nullable.ts
// @__NO_SIDE_EFFECTS__
function nullable(wrapped, default_) {
return {
kind: "schema",
type: "nullable",
reference: nullable,
expects: "(".concat(wrapped.expects, " | null)"),
async: false,
wrapped: wrapped,
"default": default_,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
if (dataset.value === null) {
if (this["default"] !== void 0) {
dataset.value = getDefault(this, dataset, config2);
}
if (dataset.value === null) {
dataset.typed = true;
return dataset;
}
}
return this.wrapped["~run"](dataset, config2);
}
};
}
// src/schemas/number/number.ts
// @__NO_SIDE_EFFECTS__
function number(message2) {
return {
kind: "schema",
type: "number",
reference: number,
expects: "number",
async: false,
message: message2,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/object/object.ts
// @__NO_SIDE_EFFECTS__
function object(entries2, message2) {
return {
kind: "schema",
type: "object",
reference: object,
expects: "Object",
async: false,
entries: entries2,
message: message2,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
var input = dataset.value;
if (input && _typeof(input) === "object") {
dataset.typed = true;
dataset.value = {};
for (var key in this.entries) {
var valueSchema = this.entries[key];
if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") &&
// @ts-expect-error
valueSchema["default"] !== void 0) {
var value2 = key in input ?
// @ts-expect-error
input[key] : getDefault(valueSchema);
var valueDataset = valueSchema["~run"]({
value: value2
}, config2);
if (valueDataset.issues) {
var pathItem = {
type: "object",
origin: "value",
input: input,
key: key,
value: value2
};
var _iterator28 = _createForOfIteratorHelper(valueDataset.issues),
_step28;
try {
for (_iterator28.s(); !(_step28 = _iterator28.n()).done;) {
var _dataset$issues11;
var issue = _step28.value;
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
(_dataset$issues11 = dataset.issues) === null || _dataset$issues11 === void 0 || _dataset$issues11.push(issue);
}
} catch (err) {
_iterator28.e(err);
} finally {
_iterator28.f();
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
dataset.value[key] = valueDataset.value;
} else if (valueSchema.fallback !== void 0) {
dataset.value[key] = getFallback(valueSchema);
} else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
_addIssue(this, "key", dataset, config2, {
input: void 0,
expected: "\"".concat(key, "\""),
path: [{
type: "object",
origin: "key",
input: input,
key: key,
// @ts-expect-error
value: input[key]
}]
});
if (config2.abortEarly) {
break;
}
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/optional/optional.ts
// @__NO_SIDE_EFFECTS__
function optional(wrapped, default_) {
return {
kind: "schema",
type: "optional",
reference: optional,
expects: "(".concat(wrapped.expects, " | undefined)"),
async: false,
wrapped: wrapped,
"default": default_,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
if (dataset.value === void 0) {
if (this["default"] !== void 0) {
dataset.value = getDefault(this, dataset, config2);
}
if (dataset.value === void 0) {
dataset.typed = true;
return dataset;
}
}
return this.wrapped["~run"](dataset, config2);
}
};
}
// src/schemas/record/record.ts
// @__NO_SIDE_EFFECTS__
function record(key, value2, message2) {
return {
kind: "schema",
type: "record",
reference: record,
expects: "Object",
async: false,
key: key,
value: value2,
message: message2,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
var input = dataset.value;
if (input && _typeof(input) === "object") {
dataset.typed = true;
dataset.value = {};
for (var entryKey in input) {
if (_isValidObjectKey(input, entryKey)) {
var entryValue = input[entryKey];
var keyDataset = this.key["~run"]({
value: entryKey
}, config2);
if (keyDataset.issues) {
var pathItem = {
type: "object",
origin: "key",
input: input,
key: entryKey,
value: entryValue
};
var _iterator37 = _createForOfIteratorHelper(keyDataset.issues),
_step37;
try {
for (_iterator37.s(); !(_step37 = _iterator37.n()).done;) {
var _dataset$issues17;
var issue = _step37.value;
issue.path = [pathItem];
(_dataset$issues17 = dataset.issues) === null || _dataset$issues17 === void 0 || _dataset$issues17.push(issue);
}
} catch (err) {
_iterator37.e(err);
} finally {
_iterator37.f();
}
if (!dataset.issues) {
dataset.issues = keyDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
var valueDataset = this.value["~run"]({
value: entryValue
}, config2);
if (valueDataset.issues) {
var _pathItem5 = {
type: "object",
origin: "value",
input: input,
key: entryKey,
value: entryValue
};
var _iterator38 = _createForOfIteratorHelper(valueDataset.issues),
_step38;
try {
for (_iterator38.s(); !(_step38 = _iterator38.n()).done;) {
var _dataset$issues18;
var _issue5 = _step38.value;
if (_issue5.path) {
_issue5.path.unshift(_pathItem5);
} else {
_issue5.path = [_pathItem5];
}
(_dataset$issues18 = dataset.issues) === null || _dataset$issues18 === void 0 || _dataset$issues18.push(_issue5);
}
} catch (err) {
_iterator38.e(err);
} finally {
_iterator38.f();
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!keyDataset.typed || !valueDataset.typed) {
dataset.typed = false;
}
if (keyDataset.typed) {
dataset.value[keyDataset.value] = valueDataset.value;
}
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/string/string.ts
// @__NO_SIDE_EFFECTS__
function string(message2) {
return {
kind: "schema",
type: "string",
reference: string,
expects: "string",
async: false,
message: message2,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
if (typeof dataset.value === "string") {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/union/utils/_subIssues/_subIssues.ts
// @__NO_SIDE_EFFECTS__
function _subIssues(datasets) {
var issues;
if (datasets) {
var _iterator61 = _createForOfIteratorHelper(datasets),
_step61;
try {
for (_iterator61.s(); !(_step61 = _iterator61.n()).done;) {
var dataset = _step61.value;
if (issues) {
var _issues;
(_issues = issues).push.apply(_issues, _toConsumableArray(dataset.issues));
} else {
issues = dataset.issues;
}
}
} catch (err) {
_iterator61.e(err);
} finally {
_iterator61.f();
}
}
return issues;
}
// src/schemas/union/union.ts
// @__NO_SIDE_EFFECTS__
function union(options, message2) {
return {
kind: "schema",
type: "union",
reference: union,
expects: _joinExpects(options.map(function (option) {
return option.expects;
}), "|"),
async: false,
options: options,
message: message2,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
var _untypedDatasets;
var validDataset;
var typedDatasets;
var untypedDatasets;
var _iterator62 = _createForOfIteratorHelper(this.options),
_step62;
try {
for (_iterator62.s(); !(_step62 = _iterator62.n()).done;) {
var schema = _step62.value;
var optionDataset = schema["~run"]({
value: dataset.value
}, config2);
if (optionDataset.typed) {
if (optionDataset.issues) {
if (typedDatasets) {
typedDatasets.push(optionDataset);
} else {
typedDatasets = [optionDataset];
}
} else {
validDataset = optionDataset;
break;
}
} else {
if (untypedDatasets) {
untypedDatasets.push(optionDataset);
} else {
untypedDatasets = [optionDataset];
}
}
}
} catch (err) {
_iterator62.e(err);
} finally {
_iterator62.f();
}
if (validDataset) {
return validDataset;
}
if (typedDatasets) {
if (typedDatasets.length === 1) {
return typedDatasets[0];
}
_addIssue(this, "type", dataset, config2, {
issues: _subIssues(typedDatasets)
});
dataset.typed = true;
} else if (((_untypedDatasets = untypedDatasets) === null || _untypedDatasets === void 0 ? void 0 : _untypedDatasets.length) === 1) {
return untypedDatasets[0];
} else {
_addIssue(this, "type", dataset, config2, {
issues: _subIssues(untypedDatasets)
});
}
return dataset;
}
};
}
// src/schemas/unknown/unknown.ts
// @__NO_SIDE_EFFECTS__
function unknown() {
return {
kind: "schema",
type: "unknown",
reference: unknown,
expects: "unknown",
async: false,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset) {
dataset.typed = true;
return dataset;
}
};
}
// src/methods/omit/omit.ts
// @__NO_SIDE_EFFECTS__
function omit(schema, keys) {
var entries2 = _objectSpread2({}, schema.entries);
var _iterator68 = _createForOfIteratorHelper(keys),
_step68;
try {
for (_iterator68.s(); !(_step68 = _iterator68.n()).done;) {
var key = _step68.value;
delete entries2[key];
}
} catch (err) {
_iterator68.e(err);
} finally {
_iterator68.f();
}
return _objectSpread2(_objectSpread2({}, schema), {}, {
entries: entries2,
get "~standard"() {
return _getStandardProps(this);
}
});
}
// src/methods/parse/parse.ts
function parse(schema, input, config2) {
var dataset = schema["~run"]({
value: input
}, getGlobalConfig(config2));
if (dataset.issues) {
throw new ValiError(dataset.issues);
}
return dataset.value;
}
// src/methods/pipe/pipe.ts
// @__NO_SIDE_EFFECTS__
function pipe() {
for (var _len3 = arguments.length, pipe2 = new Array(_len3), _key11 = 0; _key11 < _len3; _key11++) {
pipe2[_key11] = arguments[_key11];
}
return _objectSpread2(_objectSpread2({}, pipe2[0]), {}, {
pipe: pipe2,
get "~standard"() {
return _getStandardProps(this);
},
"~run": function run(dataset, config2) {
for (var _i2 = 0, _pipe = pipe2; _i2 < _pipe.length; _i2++) {
var item = _pipe[_i2];
if (item.kind !== "metadata") {
if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
dataset.typed = false;
break;
}
if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
dataset = item["~run"](dataset, config2);
}
}
}
return dataset;
}
});
}
// src/methods/safeParse/safeParse.ts
// @__NO_SIDE_EFFECTS__
function safeParse(schema, input, config2) {
var dataset = schema["~run"]({
value: input
}, getGlobalConfig(config2));
return {
typed: dataset.typed,
success: !dataset.issues,
output: dataset.value,
issues: dataset.issues
};
}
const ZHTML5Fonts = union([
literal("gothic"),
literal("mincho"),
literal("defont"),
]);
const ZFormattedComment = object({
id: optional(number(), 0),
vpos: optional(number(), 0),
content: optional(string(), ""),
date: optional(number(), 0),
date_usec: optional(number(), 0),
owner: optional(_boolean(), false),
premium: optional(_boolean(), false),
mail: optional(array(string()), []),
user_id: optional(number(), 0),
layer: optional(number(), -1),
is_my_post: optional(_boolean(), false),
});
const ZFormattedLegacyComment = omit(ZFormattedComment, [
"layer",
"user_id",
"is_my_post",
]);
const ZApiChat = object({
thread: optional(string(), ""),
no: optional(number(), 0),
vpos: number(),
date: optional(number(), 0),
date_usec: optional(number(), 0),
nicoru: optional(number(), 0),
premium: optional(number(), 0),
anonymity: optional(number(), 0),
user_id: optional(string(), ""),
mail: optional(string(), ""),
content: string(),
deleted: optional(number(), 0),
});
const ZRawApiResponse = union([
object({ chat: ZApiChat }),
record(pipe(string(), notValue("chat")), unknown()),
]);
const ZApiPing = object({
content: string(),
});
const ZApiThread = object({
resultcode: number(),
thread: string(),
server_time: number(),
ticket: string(),
revision: number(),
});
const ZApiLeaf = object({
thread: string(),
count: number(),
});
const ZApiGlobalNumRes = object({
t