5812 lines
196 KiB
JavaScript
5812 lines
196 KiB
JavaScript
import {
|
|
require_react
|
|
} from "./chunk-R7JHQV4C.js";
|
|
import {
|
|
__commonJS,
|
|
__esm,
|
|
__export,
|
|
__toCommonJS,
|
|
__toESM
|
|
} from "./chunk-PLDDJCW6.js";
|
|
|
|
// node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
|
|
var tslib_es6_exports = {};
|
|
__export(tslib_es6_exports, {
|
|
__addDisposableResource: () => __addDisposableResource,
|
|
__assign: () => __assign,
|
|
__asyncDelegator: () => __asyncDelegator,
|
|
__asyncGenerator: () => __asyncGenerator,
|
|
__asyncValues: () => __asyncValues,
|
|
__await: () => __await,
|
|
__awaiter: () => __awaiter,
|
|
__classPrivateFieldGet: () => __classPrivateFieldGet,
|
|
__classPrivateFieldIn: () => __classPrivateFieldIn,
|
|
__classPrivateFieldSet: () => __classPrivateFieldSet,
|
|
__createBinding: () => __createBinding,
|
|
__decorate: () => __decorate,
|
|
__disposeResources: () => __disposeResources,
|
|
__esDecorate: () => __esDecorate,
|
|
__exportStar: () => __exportStar,
|
|
__extends: () => __extends,
|
|
__generator: () => __generator,
|
|
__importDefault: () => __importDefault,
|
|
__importStar: () => __importStar,
|
|
__makeTemplateObject: () => __makeTemplateObject,
|
|
__metadata: () => __metadata,
|
|
__param: () => __param,
|
|
__propKey: () => __propKey,
|
|
__read: () => __read,
|
|
__rest: () => __rest,
|
|
__rewriteRelativeImportExtension: () => __rewriteRelativeImportExtension,
|
|
__runInitializers: () => __runInitializers,
|
|
__setFunctionName: () => __setFunctionName,
|
|
__spread: () => __spread,
|
|
__spreadArray: () => __spreadArray,
|
|
__spreadArrays: () => __spreadArrays,
|
|
__values: () => __values,
|
|
default: () => tslib_es6_default
|
|
});
|
|
function __extends(d, b) {
|
|
if (typeof b !== "function" && b !== null)
|
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
|
extendStatics(d, b);
|
|
function __() {
|
|
this.constructor = d;
|
|
}
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
}
|
|
function __rest(s, e2) {
|
|
var t = {};
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e2.indexOf(p) < 0)
|
|
t[p] = s[p];
|
|
if (s != null && typeof Object.getOwnPropertySymbols === "function")
|
|
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
|
if (e2.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
|
|
t[p[i]] = s[p[i]];
|
|
}
|
|
return t;
|
|
}
|
|
function __decorate(decorators, target, key, desc) {
|
|
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
|
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
|
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;
|
|
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
|
}
|
|
function __param(paramIndex, decorator) {
|
|
return function(target, key) {
|
|
decorator(target, key, paramIndex);
|
|
};
|
|
}
|
|
function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
|
|
function accept(f) {
|
|
if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
|
|
return f;
|
|
}
|
|
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
|
|
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
|
|
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
|
|
var _, done = false;
|
|
for (var i = decorators.length - 1; i >= 0; i--) {
|
|
var context = {};
|
|
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
|
|
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
|
|
context.addInitializer = function(f) {
|
|
if (done) throw new TypeError("Cannot add initializers after decoration has completed");
|
|
extraInitializers.push(accept(f || null));
|
|
};
|
|
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
|
|
if (kind === "accessor") {
|
|
if (result === void 0) continue;
|
|
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
|
|
if (_ = accept(result.get)) descriptor.get = _;
|
|
if (_ = accept(result.set)) descriptor.set = _;
|
|
if (_ = accept(result.init)) initializers.unshift(_);
|
|
} else if (_ = accept(result)) {
|
|
if (kind === "field") initializers.unshift(_);
|
|
else descriptor[key] = _;
|
|
}
|
|
}
|
|
if (target) Object.defineProperty(target, contextIn.name, descriptor);
|
|
done = true;
|
|
}
|
|
function __runInitializers(thisArg, initializers, value) {
|
|
var useValue = arguments.length > 2;
|
|
for (var i = 0; i < initializers.length; i++) {
|
|
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
|
|
}
|
|
return useValue ? value : void 0;
|
|
}
|
|
function __propKey(x) {
|
|
return typeof x === "symbol" ? x : "".concat(x);
|
|
}
|
|
function __setFunctionName(f, name, prefix) {
|
|
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
|
|
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
|
|
}
|
|
function __metadata(metadataKey, metadataValue) {
|
|
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
|
|
}
|
|
function __awaiter(thisArg, _arguments, P, generator) {
|
|
function adopt(value) {
|
|
return value instanceof P ? value : new P(function(resolve) {
|
|
resolve(value);
|
|
});
|
|
}
|
|
return new (P || (P = Promise))(function(resolve, reject) {
|
|
function fulfilled(value) {
|
|
try {
|
|
step(generator.next(value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function rejected(value) {
|
|
try {
|
|
step(generator["throw"](value));
|
|
} catch (e2) {
|
|
reject(e2);
|
|
}
|
|
}
|
|
function step(result) {
|
|
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
|
}
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
}
|
|
function __generator(thisArg, body) {
|
|
var _ = { label: 0, sent: function() {
|
|
if (t[0] & 1) throw t[1];
|
|
return t[1];
|
|
}, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
|
|
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
|
|
return this;
|
|
}), g;
|
|
function verb(n) {
|
|
return function(v) {
|
|
return step([n, v]);
|
|
};
|
|
}
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
|
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;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0:
|
|
case 1:
|
|
t = op;
|
|
break;
|
|
case 4:
|
|
_.label++;
|
|
return { value: op[1], done: false };
|
|
case 5:
|
|
_.label++;
|
|
y = op[1];
|
|
op = [0];
|
|
continue;
|
|
case 7:
|
|
op = _.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
|
|
_ = 0;
|
|
continue;
|
|
}
|
|
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
|
|
_.label = op[1];
|
|
break;
|
|
}
|
|
if (op[0] === 6 && _.label < t[1]) {
|
|
_.label = t[1];
|
|
t = op;
|
|
break;
|
|
}
|
|
if (t && _.label < t[2]) {
|
|
_.label = t[2];
|
|
_.ops.push(op);
|
|
break;
|
|
}
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e2) {
|
|
op = [6, e2];
|
|
y = 0;
|
|
} finally {
|
|
f = t = 0;
|
|
}
|
|
if (op[0] & 5) throw op[1];
|
|
return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
}
|
|
function __exportStar(m, o) {
|
|
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
|
|
}
|
|
function __values(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function() {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
}
|
|
function __read(o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e2;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
} catch (error) {
|
|
e2 = { error };
|
|
} finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
} finally {
|
|
if (e2) throw e2.error;
|
|
}
|
|
}
|
|
return ar;
|
|
}
|
|
function __spread() {
|
|
for (var ar = [], i = 0; i < arguments.length; i++)
|
|
ar = ar.concat(__read(arguments[i]));
|
|
return ar;
|
|
}
|
|
function __spreadArrays() {
|
|
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
|
|
for (var r = Array(s), k = 0, i = 0; i < il; i++)
|
|
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
|
|
r[k] = a[j];
|
|
return r;
|
|
}
|
|
function __spreadArray(to, from, pack) {
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
if (ar || !(i in from)) {
|
|
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
}
|
|
function __await(v) {
|
|
return this instanceof __await ? (this.v = v, this) : new __await(v);
|
|
}
|
|
function __asyncGenerator(thisArg, _arguments, generator) {
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
|
var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
|
return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
|
|
return this;
|
|
}, i;
|
|
function awaitReturn(f) {
|
|
return function(v) {
|
|
return Promise.resolve(v).then(f, reject);
|
|
};
|
|
}
|
|
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]);
|
|
}
|
|
}
|
|
function resume(n, v) {
|
|
try {
|
|
step(g[n](v));
|
|
} catch (e2) {
|
|
settle(q[0][3], e2);
|
|
}
|
|
}
|
|
function step(r) {
|
|
r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
|
|
}
|
|
function fulfill(value) {
|
|
resume("next", value);
|
|
}
|
|
function reject(value) {
|
|
resume("throw", value);
|
|
}
|
|
function settle(f, v) {
|
|
if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
|
|
}
|
|
}
|
|
function __asyncDelegator(o) {
|
|
var i, p;
|
|
return i = {}, verb("next"), verb("throw", function(e2) {
|
|
throw e2;
|
|
}), verb("return"), i[Symbol.iterator] = function() {
|
|
return this;
|
|
}, i;
|
|
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;
|
|
}
|
|
}
|
|
function __asyncValues(o) {
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
|
var m = o[Symbol.asyncIterator], i;
|
|
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);
|
|
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);
|
|
});
|
|
};
|
|
}
|
|
function settle(resolve, reject, d, v) {
|
|
Promise.resolve(v).then(function(v2) {
|
|
resolve({ value: v2, done: d });
|
|
}, reject);
|
|
}
|
|
}
|
|
function __makeTemplateObject(cooked, raw) {
|
|
if (Object.defineProperty) {
|
|
Object.defineProperty(cooked, "raw", { value: raw });
|
|
} else {
|
|
cooked.raw = raw;
|
|
}
|
|
return cooked;
|
|
}
|
|
function __importStar(mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) {
|
|
for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
|
|
}
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
}
|
|
function __importDefault(mod) {
|
|
return mod && mod.__esModule ? mod : { default: mod };
|
|
}
|
|
function __classPrivateFieldGet(receiver, state, kind, f) {
|
|
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
|
|
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");
|
|
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
|
|
}
|
|
function __classPrivateFieldSet(receiver, state, value, kind, f) {
|
|
if (kind === "m") throw new TypeError("Private method is not writable");
|
|
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
|
|
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");
|
|
return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
|
|
}
|
|
function __classPrivateFieldIn(state, receiver) {
|
|
if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
|
|
return typeof state === "function" ? receiver === state : state.has(receiver);
|
|
}
|
|
function __addDisposableResource(env, value, async) {
|
|
if (value !== null && value !== void 0) {
|
|
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
|
|
var dispose, inner;
|
|
if (async) {
|
|
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
|
|
dispose = value[Symbol.asyncDispose];
|
|
}
|
|
if (dispose === void 0) {
|
|
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
|
|
dispose = value[Symbol.dispose];
|
|
if (async) inner = dispose;
|
|
}
|
|
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
|
|
if (inner) dispose = function() {
|
|
try {
|
|
inner.call(this);
|
|
} catch (e2) {
|
|
return Promise.reject(e2);
|
|
}
|
|
};
|
|
env.stack.push({ value, dispose, async });
|
|
} else if (async) {
|
|
env.stack.push({ async: true });
|
|
}
|
|
return value;
|
|
}
|
|
function __disposeResources(env) {
|
|
function fail(e2) {
|
|
env.error = env.hasError ? new _SuppressedError(e2, env.error, "An error was suppressed during disposal.") : e2;
|
|
env.hasError = true;
|
|
}
|
|
var r, s = 0;
|
|
function next() {
|
|
while (r = env.stack.pop()) {
|
|
try {
|
|
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
|
|
if (r.dispose) {
|
|
var result = r.dispose.call(r.value);
|
|
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e2) {
|
|
fail(e2);
|
|
return next();
|
|
});
|
|
} else s |= 1;
|
|
} catch (e2) {
|
|
fail(e2);
|
|
}
|
|
}
|
|
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
|
|
if (env.hasError) throw env.error;
|
|
}
|
|
return next();
|
|
}
|
|
function __rewriteRelativeImportExtension(path, preserveJsx) {
|
|
if (typeof path === "string" && /^\.\.?\//.test(path)) {
|
|
return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
|
|
return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
|
|
});
|
|
}
|
|
return path;
|
|
}
|
|
var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys, _SuppressedError, tslib_es6_default;
|
|
var init_tslib_es6 = __esm({
|
|
"node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs"() {
|
|
extendStatics = function(d, b) {
|
|
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
|
|
d2.__proto__ = b2;
|
|
} || function(d2, b2) {
|
|
for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
|
|
};
|
|
return extendStatics(d, b);
|
|
};
|
|
__assign = function() {
|
|
__assign = Object.assign || function __assign2(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
__createBinding = Object.create ? function(o, m, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() {
|
|
return m[k];
|
|
} };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
} : function(o, m, k, k2) {
|
|
if (k2 === void 0) k2 = k;
|
|
o[k2] = m[k];
|
|
};
|
|
__setModuleDefault = Object.create ? function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
} : function(o, v) {
|
|
o["default"] = v;
|
|
};
|
|
ownKeys = function(o) {
|
|
ownKeys = Object.getOwnPropertyNames || function(o2) {
|
|
var ar = [];
|
|
for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
|
|
return ar;
|
|
};
|
|
return ownKeys(o);
|
|
};
|
|
_SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
|
|
var e2 = new Error(message);
|
|
return e2.name = "SuppressedError", e2.error = error, e2.suppressed = suppressed, e2;
|
|
};
|
|
tslib_es6_default = {
|
|
__extends,
|
|
__assign,
|
|
__rest,
|
|
__decorate,
|
|
__param,
|
|
__esDecorate,
|
|
__runInitializers,
|
|
__propKey,
|
|
__setFunctionName,
|
|
__metadata,
|
|
__awaiter,
|
|
__generator,
|
|
__createBinding,
|
|
__exportStar,
|
|
__values,
|
|
__read,
|
|
__spread,
|
|
__spreadArrays,
|
|
__spreadArray,
|
|
__await,
|
|
__asyncGenerator,
|
|
__asyncDelegator,
|
|
__asyncValues,
|
|
__makeTemplateObject,
|
|
__importStar,
|
|
__importDefault,
|
|
__classPrivateFieldGet,
|
|
__classPrivateFieldSet,
|
|
__classPrivateFieldIn,
|
|
__addDisposableResource,
|
|
__disposeResources,
|
|
__rewriteRelativeImportExtension
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/react.js
|
|
var require_react2 = __commonJS({
|
|
"node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/react.js"(exports, module) {
|
|
"use strict";
|
|
module.exports = function equal(a, b) {
|
|
if (a === b) return true;
|
|
if (a && b && typeof a == "object" && typeof b == "object") {
|
|
if (a.constructor !== b.constructor) return false;
|
|
var length, i, keys;
|
|
if (Array.isArray(a)) {
|
|
length = a.length;
|
|
if (length != b.length) return false;
|
|
for (i = length; i-- !== 0; )
|
|
if (!equal(a[i], b[i])) return false;
|
|
return true;
|
|
}
|
|
if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
|
|
if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
|
|
if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
|
|
keys = Object.keys(a);
|
|
length = keys.length;
|
|
if (length !== Object.keys(b).length) return false;
|
|
for (i = length; i-- !== 0; )
|
|
if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
|
|
for (i = length; i-- !== 0; ) {
|
|
var key = keys[i];
|
|
if (key === "_owner" && a.$$typeof) {
|
|
continue;
|
|
}
|
|
if (!equal(a[key], b[key])) return false;
|
|
}
|
|
return true;
|
|
}
|
|
return a !== a && b !== b;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/js-cookie@2.2.1/node_modules/js-cookie/src/js.cookie.js
|
|
var require_js_cookie = __commonJS({
|
|
"node_modules/.pnpm/js-cookie@2.2.1/node_modules/js-cookie/src/js.cookie.js"(exports, module) {
|
|
(function(factory) {
|
|
var registeredInModuleLoader;
|
|
if (typeof define === "function" && define.amd) {
|
|
define(factory);
|
|
registeredInModuleLoader = true;
|
|
}
|
|
if (typeof exports === "object") {
|
|
module.exports = factory();
|
|
registeredInModuleLoader = true;
|
|
}
|
|
if (!registeredInModuleLoader) {
|
|
var OldCookies = window.Cookies;
|
|
var api = window.Cookies = factory();
|
|
api.noConflict = function() {
|
|
window.Cookies = OldCookies;
|
|
return api;
|
|
};
|
|
}
|
|
})(function() {
|
|
function extend() {
|
|
var i = 0;
|
|
var result = {};
|
|
for (; i < arguments.length; i++) {
|
|
var attributes = arguments[i];
|
|
for (var key in attributes) {
|
|
result[key] = attributes[key];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function decode(s) {
|
|
return s.replace(/(%[0-9A-Z]{2})+/g, decodeURIComponent);
|
|
}
|
|
function init(converter) {
|
|
function api() {
|
|
}
|
|
function set(key, value, attributes) {
|
|
if (typeof document === "undefined") {
|
|
return;
|
|
}
|
|
attributes = extend({
|
|
path: "/"
|
|
}, api.defaults, attributes);
|
|
if (typeof attributes.expires === "number") {
|
|
attributes.expires = new Date(/* @__PURE__ */ new Date() * 1 + attributes.expires * 864e5);
|
|
}
|
|
attributes.expires = attributes.expires ? attributes.expires.toUTCString() : "";
|
|
try {
|
|
var result = JSON.stringify(value);
|
|
if (/^[\{\[]/.test(result)) {
|
|
value = result;
|
|
}
|
|
} catch (e2) {
|
|
}
|
|
value = converter.write ? converter.write(value, key) : encodeURIComponent(String(value)).replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);
|
|
key = encodeURIComponent(String(key)).replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent).replace(/[\(\)]/g, escape);
|
|
var stringifiedAttributes = "";
|
|
for (var attributeName in attributes) {
|
|
if (!attributes[attributeName]) {
|
|
continue;
|
|
}
|
|
stringifiedAttributes += "; " + attributeName;
|
|
if (attributes[attributeName] === true) {
|
|
continue;
|
|
}
|
|
stringifiedAttributes += "=" + attributes[attributeName].split(";")[0];
|
|
}
|
|
return document.cookie = key + "=" + value + stringifiedAttributes;
|
|
}
|
|
function get(key, json) {
|
|
if (typeof document === "undefined") {
|
|
return;
|
|
}
|
|
var jar = {};
|
|
var cookies = document.cookie ? document.cookie.split("; ") : [];
|
|
var i = 0;
|
|
for (; i < cookies.length; i++) {
|
|
var parts = cookies[i].split("=");
|
|
var cookie = parts.slice(1).join("=");
|
|
if (!json && cookie.charAt(0) === '"') {
|
|
cookie = cookie.slice(1, -1);
|
|
}
|
|
try {
|
|
var name = decode(parts[0]);
|
|
cookie = (converter.read || converter)(cookie, name) || decode(cookie);
|
|
if (json) {
|
|
try {
|
|
cookie = JSON.parse(cookie);
|
|
} catch (e2) {
|
|
}
|
|
}
|
|
jar[name] = cookie;
|
|
if (key === name) {
|
|
break;
|
|
}
|
|
} catch (e2) {
|
|
}
|
|
}
|
|
return key ? jar[key] : jar;
|
|
}
|
|
api.set = set;
|
|
api.get = function(key) {
|
|
return get(
|
|
key,
|
|
false
|
|
/* read as raw */
|
|
);
|
|
};
|
|
api.getJSON = function(key) {
|
|
return get(
|
|
key,
|
|
true
|
|
/* read as json */
|
|
);
|
|
};
|
|
api.remove = function(key, attributes) {
|
|
set(key, "", extend(attributes, {
|
|
expires: -1
|
|
}));
|
|
};
|
|
api.defaults = {};
|
|
api.withConverter = init;
|
|
return api;
|
|
}
|
|
return init(function() {
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/toggle-selection@1.0.6/node_modules/toggle-selection/index.js
|
|
var require_toggle_selection = __commonJS({
|
|
"node_modules/.pnpm/toggle-selection@1.0.6/node_modules/toggle-selection/index.js"(exports, module) {
|
|
module.exports = function() {
|
|
var selection = document.getSelection();
|
|
if (!selection.rangeCount) {
|
|
return function() {
|
|
};
|
|
}
|
|
var active = document.activeElement;
|
|
var ranges = [];
|
|
for (var i = 0; i < selection.rangeCount; i++) {
|
|
ranges.push(selection.getRangeAt(i));
|
|
}
|
|
switch (active.tagName.toUpperCase()) {
|
|
// .toUpperCase handles XHTML
|
|
case "INPUT":
|
|
case "TEXTAREA":
|
|
active.blur();
|
|
break;
|
|
default:
|
|
active = null;
|
|
break;
|
|
}
|
|
selection.removeAllRanges();
|
|
return function() {
|
|
selection.type === "Caret" && selection.removeAllRanges();
|
|
if (!selection.rangeCount) {
|
|
ranges.forEach(function(range) {
|
|
selection.addRange(range);
|
|
});
|
|
}
|
|
active && active.focus();
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/copy-to-clipboard@3.3.3/node_modules/copy-to-clipboard/index.js
|
|
var require_copy_to_clipboard = __commonJS({
|
|
"node_modules/.pnpm/copy-to-clipboard@3.3.3/node_modules/copy-to-clipboard/index.js"(exports, module) {
|
|
"use strict";
|
|
var deselectCurrent = require_toggle_selection();
|
|
var clipboardToIE11Formatting = {
|
|
"text/plain": "Text",
|
|
"text/html": "Url",
|
|
"default": "Text"
|
|
};
|
|
var defaultMessage = "Copy to clipboard: #{key}, Enter";
|
|
function format(message) {
|
|
var copyKey = (/mac os x/i.test(navigator.userAgent) ? "⌘" : "Ctrl") + "+C";
|
|
return message.replace(/#{\s*key\s*}/g, copyKey);
|
|
}
|
|
function copy(text, options) {
|
|
var debug, message, reselectPrevious, range, selection, mark, success = false;
|
|
if (!options) {
|
|
options = {};
|
|
}
|
|
debug = options.debug || false;
|
|
try {
|
|
reselectPrevious = deselectCurrent();
|
|
range = document.createRange();
|
|
selection = document.getSelection();
|
|
mark = document.createElement("span");
|
|
mark.textContent = text;
|
|
mark.ariaHidden = "true";
|
|
mark.style.all = "unset";
|
|
mark.style.position = "fixed";
|
|
mark.style.top = 0;
|
|
mark.style.clip = "rect(0, 0, 0, 0)";
|
|
mark.style.whiteSpace = "pre";
|
|
mark.style.webkitUserSelect = "text";
|
|
mark.style.MozUserSelect = "text";
|
|
mark.style.msUserSelect = "text";
|
|
mark.style.userSelect = "text";
|
|
mark.addEventListener("copy", function(e2) {
|
|
e2.stopPropagation();
|
|
if (options.format) {
|
|
e2.preventDefault();
|
|
if (typeof e2.clipboardData === "undefined") {
|
|
debug && console.warn("unable to use e.clipboardData");
|
|
debug && console.warn("trying IE specific stuff");
|
|
window.clipboardData.clearData();
|
|
var format2 = clipboardToIE11Formatting[options.format] || clipboardToIE11Formatting["default"];
|
|
window.clipboardData.setData(format2, text);
|
|
} else {
|
|
e2.clipboardData.clearData();
|
|
e2.clipboardData.setData(options.format, text);
|
|
}
|
|
}
|
|
if (options.onCopy) {
|
|
e2.preventDefault();
|
|
options.onCopy(e2.clipboardData);
|
|
}
|
|
});
|
|
document.body.appendChild(mark);
|
|
range.selectNodeContents(mark);
|
|
selection.addRange(range);
|
|
var successful = document.execCommand("copy");
|
|
if (!successful) {
|
|
throw new Error("copy command was unsuccessful");
|
|
}
|
|
success = true;
|
|
} catch (err) {
|
|
debug && console.error("unable to copy using execCommand: ", err);
|
|
debug && console.warn("trying IE specific stuff");
|
|
try {
|
|
window.clipboardData.setData(options.format || "text", text);
|
|
options.onCopy && options.onCopy(window.clipboardData);
|
|
success = true;
|
|
} catch (err2) {
|
|
debug && console.error("unable to copy using clipboardData: ", err2);
|
|
debug && console.error("falling back to prompt");
|
|
message = format("message" in options ? options.message : defaultMessage);
|
|
window.prompt(message, text);
|
|
}
|
|
} finally {
|
|
if (selection) {
|
|
if (typeof selection.removeRange == "function") {
|
|
selection.removeRange(range);
|
|
} else {
|
|
selection.removeAllRanges();
|
|
}
|
|
}
|
|
if (mark) {
|
|
document.body.removeChild(mark);
|
|
}
|
|
reselectPrevious();
|
|
}
|
|
return success;
|
|
}
|
|
module.exports = copy;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/index.js
|
|
var require_nano_css = __commonJS({
|
|
"node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/index.js"(exports) {
|
|
"use strict";
|
|
var KEBAB_REGEX = /[A-Z]/g;
|
|
var hash = function(str) {
|
|
var h = 5381, i = str.length;
|
|
while (i) h = h * 33 ^ str.charCodeAt(--i);
|
|
return "_" + (h >>> 0).toString(36);
|
|
};
|
|
exports.create = function(config) {
|
|
config = config || {};
|
|
var assign = config.assign || Object.assign;
|
|
var client = typeof window === "object";
|
|
if (true) {
|
|
if (client) {
|
|
if (typeof document !== "object" || !document.getElementsByTagName("HTML")) {
|
|
console.error(
|
|
'nano-css detected browser environment because of "window" global, but "document" global seems to be defective.'
|
|
);
|
|
}
|
|
}
|
|
}
|
|
var renderer = assign({
|
|
raw: "",
|
|
pfx: "_",
|
|
client,
|
|
assign,
|
|
stringify: JSON.stringify,
|
|
kebab: function(prop) {
|
|
return prop.replace(KEBAB_REGEX, "-$&").toLowerCase();
|
|
},
|
|
decl: function(key, value) {
|
|
key = renderer.kebab(key);
|
|
return key + ":" + value + ";";
|
|
},
|
|
hash: function(obj) {
|
|
return hash(renderer.stringify(obj));
|
|
},
|
|
selector: function(parent, selector) {
|
|
return parent + (selector[0] === ":" ? "" : " ") + selector;
|
|
},
|
|
putRaw: function(rawCssRule) {
|
|
renderer.raw += rawCssRule;
|
|
}
|
|
}, config);
|
|
if (renderer.client) {
|
|
if (!renderer.sh)
|
|
document.head.appendChild(renderer.sh = document.createElement("style"));
|
|
if (true) {
|
|
renderer.sh.setAttribute("data-nano-css-dev", "");
|
|
renderer.shTest = document.createElement("style");
|
|
renderer.shTest.setAttribute("data-nano-css-dev-tests", "");
|
|
document.head.appendChild(renderer.shTest);
|
|
}
|
|
renderer.putRaw = function(rawCssRule) {
|
|
if (false) {
|
|
var sheet = renderer.sh.sheet;
|
|
try {
|
|
sheet.insertRule(rawCssRule, sheet.cssRules.length);
|
|
} catch (error) {
|
|
}
|
|
} else {
|
|
try {
|
|
renderer.shTest.sheet.insertRule(rawCssRule, renderer.shTest.sheet.cssRules.length);
|
|
} catch (error) {
|
|
if (config.verbose) {
|
|
console.error(error);
|
|
}
|
|
}
|
|
renderer.sh.appendChild(document.createTextNode(rawCssRule));
|
|
}
|
|
};
|
|
}
|
|
renderer.put = function(selector, decls, atrule) {
|
|
var str = "";
|
|
var prop, value;
|
|
var postponed = [];
|
|
for (prop in decls) {
|
|
value = decls[prop];
|
|
if (value instanceof Object && !(value instanceof Array)) {
|
|
postponed.push(prop);
|
|
} else {
|
|
if (!renderer.sourcemaps) {
|
|
str += " " + renderer.decl(prop, value, selector, atrule) + "\n";
|
|
} else {
|
|
str += renderer.decl(prop, value, selector, atrule);
|
|
}
|
|
}
|
|
}
|
|
if (str) {
|
|
if (!renderer.sourcemaps) {
|
|
str = "\n" + selector + " {\n" + str + "}\n";
|
|
} else {
|
|
str = selector + "{" + str + "}";
|
|
}
|
|
renderer.putRaw(atrule ? atrule + "{" + str + "}" : str);
|
|
}
|
|
for (var i = 0; i < postponed.length; i++) {
|
|
prop = postponed[i];
|
|
if (prop[0] === "@" && prop !== "@font-face") {
|
|
renderer.putAt(selector, decls[prop], prop);
|
|
} else {
|
|
renderer.put(renderer.selector(selector, prop), decls[prop], atrule);
|
|
}
|
|
}
|
|
};
|
|
renderer.putAt = renderer.put;
|
|
return renderer;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/addon/__dev__/warnOnMissingDependencies.js
|
|
var require_warnOnMissingDependencies = __commonJS({
|
|
"node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/addon/__dev__/warnOnMissingDependencies.js"(exports, module) {
|
|
"use strict";
|
|
var pkgName = "nano-css";
|
|
module.exports = function warnOnMissingDependencies(addon, renderer, deps) {
|
|
var missing = [];
|
|
for (var i = 0; i < deps.length; i++) {
|
|
var name = deps[i];
|
|
if (!renderer[name]) {
|
|
missing.push(name);
|
|
}
|
|
}
|
|
if (missing.length) {
|
|
var str = 'Addon "' + addon + '" is missing the following dependencies:';
|
|
for (var j = 0; j < missing.length; j++) {
|
|
str += '\n require("' + pkgName + "/addon/" + missing[j] + '").addon(nano);';
|
|
}
|
|
throw new Error(str);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/addon/cssom.js
|
|
var require_cssom = __commonJS({
|
|
"node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/addon/cssom.js"(exports) {
|
|
"use strict";
|
|
exports.addon = function(renderer) {
|
|
if (!renderer.client) return;
|
|
if (true) {
|
|
require_warnOnMissingDependencies()("cssom", renderer, ["sh"]);
|
|
}
|
|
document.head.appendChild(renderer.msh = document.createElement("style"));
|
|
renderer.createRule = function(selector, prelude) {
|
|
var rawCss = selector + "{}";
|
|
if (prelude) rawCss = prelude + "{" + rawCss + "}";
|
|
var sheet = prelude ? renderer.msh.sheet : renderer.sh.sheet;
|
|
var index = sheet.insertRule(rawCss, sheet.cssRules.length);
|
|
var rule = (sheet.cssRules || sheet.rules)[index];
|
|
rule.index = index;
|
|
if (prelude) {
|
|
var selectorRule = (rule.cssRules || rule.rules)[0];
|
|
rule.style = selectorRule.style;
|
|
rule.styleMap = selectorRule.styleMap;
|
|
}
|
|
return rule;
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/addon/vcssom/removeRule.js
|
|
var require_removeRule = __commonJS({
|
|
"node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/addon/vcssom/removeRule.js"(exports) {
|
|
function removeRule(rule) {
|
|
var maxIndex = rule.index;
|
|
var sh = rule.parentStyleSheet;
|
|
var rules = sh.cssRules || sh.rules;
|
|
maxIndex = Math.max(maxIndex, rules.length - 1);
|
|
while (maxIndex >= 0) {
|
|
if (rules[maxIndex] === rule) {
|
|
sh.deleteRule(maxIndex);
|
|
break;
|
|
}
|
|
maxIndex--;
|
|
}
|
|
}
|
|
exports.removeRule = removeRule;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/addon/vcssom.js
|
|
var require_vcssom = __commonJS({
|
|
"node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/addon/vcssom.js"(exports) {
|
|
"use strict";
|
|
var removeRule = require_removeRule().removeRule;
|
|
exports.addon = function(renderer) {
|
|
if (!renderer.client) return;
|
|
if (true) {
|
|
require_warnOnMissingDependencies()("cssom", renderer, ["createRule"]);
|
|
}
|
|
var kebab = renderer.kebab;
|
|
function VRule(selector, prelude) {
|
|
this.rule = renderer.createRule(selector, prelude);
|
|
this.decl = {};
|
|
}
|
|
VRule.prototype.diff = function(newDecl) {
|
|
var oldDecl = this.decl;
|
|
var style = this.rule.style;
|
|
var property;
|
|
for (property in oldDecl)
|
|
if (newDecl[property] === void 0)
|
|
style.removeProperty(property);
|
|
for (property in newDecl)
|
|
if (newDecl[property] !== oldDecl[property])
|
|
style.setProperty(kebab(property), newDecl[property]);
|
|
this.decl = newDecl;
|
|
};
|
|
VRule.prototype.del = function() {
|
|
removeRule(this.rule);
|
|
};
|
|
function VSheet() {
|
|
this.tree = {};
|
|
}
|
|
VSheet.prototype.diff = function(newTree) {
|
|
var oldTree = this.tree;
|
|
for (var prelude in oldTree) {
|
|
if (newTree[prelude] === void 0) {
|
|
var rules = oldTree[prelude];
|
|
for (var selector in rules)
|
|
rules[selector].del();
|
|
}
|
|
}
|
|
for (var prelude in newTree) {
|
|
if (oldTree[prelude] === void 0) {
|
|
for (var selector in newTree[prelude]) {
|
|
var rule = new VRule(selector, prelude);
|
|
rule.diff(newTree[prelude][selector]);
|
|
newTree[prelude][selector] = rule;
|
|
}
|
|
} else {
|
|
var oldRules = oldTree[prelude];
|
|
var newRules = newTree[prelude];
|
|
for (var selector in oldRules)
|
|
if (!newRules[selector])
|
|
oldRules[selector].del();
|
|
for (var selector in newRules) {
|
|
var rule = oldRules[selector];
|
|
if (rule) {
|
|
rule.diff(newRules[selector]);
|
|
newRules[selector] = rule;
|
|
} else {
|
|
rule = new VRule(selector, prelude);
|
|
rule.diff(newRules[selector]);
|
|
newRules[selector] = rule;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.tree = newTree;
|
|
};
|
|
renderer.VRule = VRule;
|
|
renderer.VSheet = VSheet;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/addon/vcssom/cssToTree.js
|
|
var require_cssToTree = __commonJS({
|
|
"node_modules/.pnpm/nano-css@5.6.2_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/nano-css/addon/vcssom/cssToTree.js"(exports) {
|
|
function cssToTree2(tree, css, selector, prelude) {
|
|
var declarations = {};
|
|
var hasDeclarations = false;
|
|
var key, value;
|
|
for (key in css) {
|
|
value = css[key];
|
|
if (typeof value !== "object") {
|
|
hasDeclarations = true;
|
|
declarations[key] = value;
|
|
}
|
|
}
|
|
if (hasDeclarations) {
|
|
if (!tree[prelude]) tree[prelude] = {};
|
|
tree[prelude][selector] = declarations;
|
|
}
|
|
for (key in css) {
|
|
value = css[key];
|
|
if (typeof value === "object") {
|
|
if (key[0] === "@") {
|
|
cssToTree2(tree, value, selector, key);
|
|
} else {
|
|
var hasCurrentSymbol = key.indexOf("&") > -1;
|
|
var selectorParts = selector.split(",");
|
|
if (hasCurrentSymbol) {
|
|
for (var i = 0; i < selectorParts.length; i++) {
|
|
selectorParts[i] = key.replace(/&/g, selectorParts[i]);
|
|
}
|
|
} else {
|
|
for (var i = 0; i < selectorParts.length; i++) {
|
|
selectorParts[i] = selectorParts[i] + " " + key;
|
|
}
|
|
}
|
|
cssToTree2(tree, value, selectorParts.join(","), prelude);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
exports.cssToTree = cssToTree2;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/screenfull@5.2.0/node_modules/screenfull/dist/screenfull.js
|
|
var require_screenfull = __commonJS({
|
|
"node_modules/.pnpm/screenfull@5.2.0/node_modules/screenfull/dist/screenfull.js"(exports, module) {
|
|
(function() {
|
|
"use strict";
|
|
var document2 = typeof window !== "undefined" && typeof window.document !== "undefined" ? window.document : {};
|
|
var isCommonjs = typeof module !== "undefined" && module.exports;
|
|
var fn = function() {
|
|
var val;
|
|
var fnMap = [
|
|
[
|
|
"requestFullscreen",
|
|
"exitFullscreen",
|
|
"fullscreenElement",
|
|
"fullscreenEnabled",
|
|
"fullscreenchange",
|
|
"fullscreenerror"
|
|
],
|
|
// New WebKit
|
|
[
|
|
"webkitRequestFullscreen",
|
|
"webkitExitFullscreen",
|
|
"webkitFullscreenElement",
|
|
"webkitFullscreenEnabled",
|
|
"webkitfullscreenchange",
|
|
"webkitfullscreenerror"
|
|
],
|
|
// Old WebKit
|
|
[
|
|
"webkitRequestFullScreen",
|
|
"webkitCancelFullScreen",
|
|
"webkitCurrentFullScreenElement",
|
|
"webkitCancelFullScreen",
|
|
"webkitfullscreenchange",
|
|
"webkitfullscreenerror"
|
|
],
|
|
[
|
|
"mozRequestFullScreen",
|
|
"mozCancelFullScreen",
|
|
"mozFullScreenElement",
|
|
"mozFullScreenEnabled",
|
|
"mozfullscreenchange",
|
|
"mozfullscreenerror"
|
|
],
|
|
[
|
|
"msRequestFullscreen",
|
|
"msExitFullscreen",
|
|
"msFullscreenElement",
|
|
"msFullscreenEnabled",
|
|
"MSFullscreenChange",
|
|
"MSFullscreenError"
|
|
]
|
|
];
|
|
var i = 0;
|
|
var l = fnMap.length;
|
|
var ret = {};
|
|
for (; i < l; i++) {
|
|
val = fnMap[i];
|
|
if (val && val[1] in document2) {
|
|
for (i = 0; i < val.length; i++) {
|
|
ret[fnMap[0][i]] = val[i];
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
return false;
|
|
}();
|
|
var eventNameMap = {
|
|
change: fn.fullscreenchange,
|
|
error: fn.fullscreenerror
|
|
};
|
|
var screenfull2 = {
|
|
request: function(element, options) {
|
|
return new Promise((function(resolve, reject) {
|
|
var onFullScreenEntered = (function() {
|
|
this.off("change", onFullScreenEntered);
|
|
resolve();
|
|
}).bind(this);
|
|
this.on("change", onFullScreenEntered);
|
|
element = element || document2.documentElement;
|
|
var returnPromise = element[fn.requestFullscreen](options);
|
|
if (returnPromise instanceof Promise) {
|
|
returnPromise.then(onFullScreenEntered).catch(reject);
|
|
}
|
|
}).bind(this));
|
|
},
|
|
exit: function() {
|
|
return new Promise((function(resolve, reject) {
|
|
if (!this.isFullscreen) {
|
|
resolve();
|
|
return;
|
|
}
|
|
var onFullScreenExit = (function() {
|
|
this.off("change", onFullScreenExit);
|
|
resolve();
|
|
}).bind(this);
|
|
this.on("change", onFullScreenExit);
|
|
var returnPromise = document2[fn.exitFullscreen]();
|
|
if (returnPromise instanceof Promise) {
|
|
returnPromise.then(onFullScreenExit).catch(reject);
|
|
}
|
|
}).bind(this));
|
|
},
|
|
toggle: function(element, options) {
|
|
return this.isFullscreen ? this.exit() : this.request(element, options);
|
|
},
|
|
onchange: function(callback) {
|
|
this.on("change", callback);
|
|
},
|
|
onerror: function(callback) {
|
|
this.on("error", callback);
|
|
},
|
|
on: function(event, callback) {
|
|
var eventName = eventNameMap[event];
|
|
if (eventName) {
|
|
document2.addEventListener(eventName, callback, false);
|
|
}
|
|
},
|
|
off: function(event, callback) {
|
|
var eventName = eventNameMap[event];
|
|
if (eventName) {
|
|
document2.removeEventListener(eventName, callback, false);
|
|
}
|
|
},
|
|
raw: fn
|
|
};
|
|
if (!fn) {
|
|
if (isCommonjs) {
|
|
module.exports = { isEnabled: false };
|
|
} else {
|
|
window.screenfull = { isEnabled: false };
|
|
}
|
|
return;
|
|
}
|
|
Object.defineProperties(screenfull2, {
|
|
isFullscreen: {
|
|
get: function() {
|
|
return Boolean(document2[fn.fullscreenElement]);
|
|
}
|
|
},
|
|
element: {
|
|
enumerable: true,
|
|
get: function() {
|
|
return document2[fn.fullscreenElement];
|
|
}
|
|
},
|
|
isEnabled: {
|
|
enumerable: true,
|
|
get: function() {
|
|
return Boolean(document2[fn.fullscreenEnabled]);
|
|
}
|
|
}
|
|
});
|
|
if (isCommonjs) {
|
|
module.exports = screenfull2;
|
|
} else {
|
|
window.screenfull = screenfull2;
|
|
}
|
|
})();
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/render.js
|
|
var require_render = __commonJS({
|
|
"node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/render.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
|
|
var react_1 = require_react();
|
|
var isReact16Plus = parseInt(react_1.version.substr(0, react_1.version.indexOf("."))) > 15;
|
|
var isFn = function(fn) {
|
|
return typeof fn === "function";
|
|
};
|
|
var render2 = function(props, data) {
|
|
var more = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
more[_i - 2] = arguments[_i];
|
|
}
|
|
if (true) {
|
|
if (typeof props !== "object") {
|
|
throw new TypeError("renderChildren(props, data) first argument must be a props object.");
|
|
}
|
|
var children_1 = props.children, render_1 = props.render;
|
|
if (isFn(children_1) && isFn(render_1)) {
|
|
console.warn('Both "render" and "children" are specified for in a universal interface component. Children will be used.');
|
|
console.trace();
|
|
}
|
|
if (typeof data !== "object") {
|
|
console.warn("Universal component interface normally expects data to be an object, " + ('"' + typeof data + '" received.'));
|
|
console.trace();
|
|
}
|
|
}
|
|
var render3 = props.render, _a = props.children, children = _a === void 0 ? render3 : _a, component = props.component, _b = props.comp, comp = _b === void 0 ? component : _b;
|
|
if (isFn(children))
|
|
return children.apply(void 0, tslib_1.__spreadArrays([data], more));
|
|
if (comp) {
|
|
return react_1.createElement(comp, data);
|
|
}
|
|
if (children instanceof Array)
|
|
return isReact16Plus ? children : react_1.createElement.apply(void 0, tslib_1.__spreadArrays(["div", null], children));
|
|
if (children && children instanceof Object) {
|
|
if (true) {
|
|
if (!children.type || typeof children.type !== "string" && typeof children.type !== "function" && typeof children.type !== "symbol") {
|
|
console.warn('Universal component interface received object as children, expected React element, but received unexpected React "type".');
|
|
console.trace();
|
|
}
|
|
if (typeof children.type === "string")
|
|
return children;
|
|
return react_1.cloneElement(children, Object.assign({}, children.props, data));
|
|
} else {
|
|
if (typeof children.type === "string")
|
|
return children;
|
|
return react_1.cloneElement(children, Object.assign({}, children.props, data));
|
|
}
|
|
}
|
|
return children || null;
|
|
};
|
|
exports.default = render2;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/wrapInStatefulComponent.js
|
|
var require_wrapInStatefulComponent = __commonJS({
|
|
"node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/wrapInStatefulComponent.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
|
|
var React4 = tslib_1.__importStar(require_react());
|
|
var wrapInStatefulComponent = function(Comp) {
|
|
var Decorated = function(_super) {
|
|
tslib_1.__extends(class_1, _super);
|
|
function class_1() {
|
|
return _super !== null && _super.apply(this, arguments) || this;
|
|
}
|
|
class_1.prototype.render = function() {
|
|
return Comp(this.props, this.context);
|
|
};
|
|
return class_1;
|
|
}(React4.Component);
|
|
if (true) {
|
|
Decorated.displayName = "Decorated(" + (Comp.displayName || Comp.name) + ")";
|
|
}
|
|
return Decorated;
|
|
};
|
|
exports.default = wrapInStatefulComponent;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/addClassDecoratorSupport.js
|
|
var require_addClassDecoratorSupport = __commonJS({
|
|
"node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/addClassDecoratorSupport.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
|
|
var wrapInStatefulComponent_1 = tslib_1.__importDefault(require_wrapInStatefulComponent());
|
|
var addClassDecoratorSupport = function(Comp) {
|
|
var isSFC = !Comp.prototype;
|
|
return !isSFC ? Comp : wrapInStatefulComponent_1.default(Comp);
|
|
};
|
|
exports.default = addClassDecoratorSupport;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/createEnhancer.js
|
|
var require_createEnhancer = __commonJS({
|
|
"node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/createEnhancer.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.divWrapper = void 0;
|
|
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
|
|
var React4 = tslib_1.__importStar(require_react());
|
|
var addClassDecoratorSupport_1 = tslib_1.__importDefault(require_addClassDecoratorSupport());
|
|
var h = React4.createElement;
|
|
var noWrap = function(Comp, propName, props, state) {
|
|
var _a;
|
|
return h(Comp, propName ? tslib_1.__assign((_a = {}, _a[propName] = state, _a), props) : tslib_1.__assign(tslib_1.__assign({}, state), props));
|
|
};
|
|
exports.divWrapper = function(Comp, propName, props, state) {
|
|
return h("div", null, noWrap(Comp, propName, props, state));
|
|
};
|
|
var createEnhancer = function(Facc, prop, wrapper) {
|
|
if (wrapper === void 0) {
|
|
wrapper = noWrap;
|
|
}
|
|
var enhancer = function(Comp, propName, faccProps) {
|
|
if (propName === void 0) {
|
|
propName = prop;
|
|
}
|
|
if (faccProps === void 0) {
|
|
faccProps = null;
|
|
}
|
|
var isClassDecoratorMethodCall = typeof Comp === "string";
|
|
if (isClassDecoratorMethodCall) {
|
|
return function(Klass) {
|
|
return enhancer(Klass, Comp || prop, propName);
|
|
};
|
|
}
|
|
var Enhanced = function(props) {
|
|
return h(Facc, faccProps, function(state) {
|
|
return wrapper(Comp, propName, props, state);
|
|
});
|
|
};
|
|
if (true) {
|
|
Enhanced.displayName = (Facc.displayName || Facc.name) + "(" + (Comp.displayName || Comp.name) + ")";
|
|
}
|
|
return isClassDecoratorMethodCall ? addClassDecoratorSupport_1.default(Enhanced) : Enhanced;
|
|
};
|
|
return enhancer;
|
|
};
|
|
exports.default = createEnhancer;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/hookToRenderProp.js
|
|
var require_hookToRenderProp = __commonJS({
|
|
"node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/hookToRenderProp.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
|
|
var render_1 = tslib_1.__importDefault(require_render());
|
|
var defaultMapPropsToArgs = function(props) {
|
|
return [props];
|
|
};
|
|
var hookToRenderProp = function(hook, mapPropsToArgs) {
|
|
if (mapPropsToArgs === void 0) {
|
|
mapPropsToArgs = defaultMapPropsToArgs;
|
|
}
|
|
return function(props) {
|
|
return render_1.default(props, hook.apply(void 0, mapPropsToArgs(props)));
|
|
};
|
|
};
|
|
exports.default = hookToRenderProp;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/index.js
|
|
var require_lib = __commonJS({
|
|
"node_modules/.pnpm/react-universal-interface@0.6.2_react@19.1.1_tslib@2.8.1/node_modules/react-universal-interface/lib/index.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.hookToRenderProp = exports.createEnhancer = exports.render = void 0;
|
|
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
|
|
var render_1 = tslib_1.__importDefault(require_render());
|
|
exports.render = render_1.default;
|
|
var createEnhancer_1 = tslib_1.__importDefault(require_createEnhancer());
|
|
exports.createEnhancer = createEnhancer_1.default;
|
|
var hookToRenderProp_1 = tslib_1.__importDefault(require_hookToRenderProp());
|
|
exports.hookToRenderProp = hookToRenderProp_1.default;
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/fast-shallow-equal@1.0.0/node_modules/fast-shallow-equal/index.js
|
|
var require_fast_shallow_equal = __commonJS({
|
|
"node_modules/.pnpm/fast-shallow-equal@1.0.0/node_modules/fast-shallow-equal/index.js"(exports) {
|
|
var keyList = Object.keys;
|
|
exports.equal = function equal(a, b) {
|
|
if (a === b) return true;
|
|
if (!(a instanceof Object) || !(b instanceof Object)) return false;
|
|
var keys = keyList(a);
|
|
var length = keys.length;
|
|
for (var i = 0; i < length; i++)
|
|
if (!(keys[i] in b)) return false;
|
|
for (var i = 0; i < length; i++)
|
|
if (a[keys[i]] !== b[keys[i]]) return false;
|
|
return length === keyList(b).length;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/ts-easing@0.2.0/node_modules/ts-easing/lib/index.js
|
|
var require_lib2 = __commonJS({
|
|
"node_modules/.pnpm/ts-easing@0.2.0/node_modules/ts-easing/lib/index.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.easing = {
|
|
// No easing, no acceleration
|
|
linear: function(t) {
|
|
return t;
|
|
},
|
|
// Accelerates fast, then slows quickly towards end.
|
|
quadratic: function(t) {
|
|
return t * (-(t * t) * t + 4 * t * t - 6 * t + 4);
|
|
},
|
|
// Overshoots over 1 and then returns to 1 towards end.
|
|
cubic: function(t) {
|
|
return t * (4 * t * t - 9 * t + 6);
|
|
},
|
|
// Overshoots over 1 multiple times - wiggles around 1.
|
|
elastic: function(t) {
|
|
return t * (33 * t * t * t * t - 106 * t * t * t + 126 * t * t - 67 * t + 15);
|
|
},
|
|
// Accelerating from zero velocity
|
|
inQuad: function(t) {
|
|
return t * t;
|
|
},
|
|
// Decelerating to zero velocity
|
|
outQuad: function(t) {
|
|
return t * (2 - t);
|
|
},
|
|
// Acceleration until halfway, then deceleration
|
|
inOutQuad: function(t) {
|
|
return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
|
|
},
|
|
// Accelerating from zero velocity
|
|
inCubic: function(t) {
|
|
return t * t * t;
|
|
},
|
|
// Decelerating to zero velocity
|
|
outCubic: function(t) {
|
|
return --t * t * t + 1;
|
|
},
|
|
// Acceleration until halfway, then deceleration
|
|
inOutCubic: function(t) {
|
|
return t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
|
|
},
|
|
// Accelerating from zero velocity
|
|
inQuart: function(t) {
|
|
return t * t * t * t;
|
|
},
|
|
// Decelerating to zero velocity
|
|
outQuart: function(t) {
|
|
return 1 - --t * t * t * t;
|
|
},
|
|
// Acceleration until halfway, then deceleration
|
|
inOutQuart: function(t) {
|
|
return t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t;
|
|
},
|
|
// Accelerating from zero velocity
|
|
inQuint: function(t) {
|
|
return t * t * t * t * t;
|
|
},
|
|
// Decelerating to zero velocity
|
|
outQuint: function(t) {
|
|
return 1 + --t * t * t * t * t;
|
|
},
|
|
// Acceleration until halfway, then deceleration
|
|
inOutQuint: function(t) {
|
|
return t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * --t * t * t * t * t;
|
|
},
|
|
// Accelerating from zero velocity
|
|
inSine: function(t) {
|
|
return -Math.cos(t * (Math.PI / 2)) + 1;
|
|
},
|
|
// Decelerating to zero velocity
|
|
outSine: function(t) {
|
|
return Math.sin(t * (Math.PI / 2));
|
|
},
|
|
// Accelerating until halfway, then decelerating
|
|
inOutSine: function(t) {
|
|
return -(Math.cos(Math.PI * t) - 1) / 2;
|
|
},
|
|
// Exponential accelerating from zero velocity
|
|
inExpo: function(t) {
|
|
return Math.pow(2, 10 * (t - 1));
|
|
},
|
|
// Exponential decelerating to zero velocity
|
|
outExpo: function(t) {
|
|
return -Math.pow(2, -10 * t) + 1;
|
|
},
|
|
// Exponential accelerating until halfway, then decelerating
|
|
inOutExpo: function(t) {
|
|
t /= 0.5;
|
|
if (t < 1)
|
|
return Math.pow(2, 10 * (t - 1)) / 2;
|
|
t--;
|
|
return (-Math.pow(2, -10 * t) + 2) / 2;
|
|
},
|
|
// Circular accelerating from zero velocity
|
|
inCirc: function(t) {
|
|
return -Math.sqrt(1 - t * t) + 1;
|
|
},
|
|
// Circular decelerating to zero velocity Moves VERY fast at the beginning and
|
|
// then quickly slows down in the middle. This tween can actually be used
|
|
// in continuous transitions where target value changes all the time,
|
|
// because of the very quick start, it hides the jitter between target value changes.
|
|
outCirc: function(t) {
|
|
return Math.sqrt(1 - (t = t - 1) * t);
|
|
},
|
|
// Circular acceleration until halfway, then deceleration
|
|
inOutCirc: function(t) {
|
|
t /= 0.5;
|
|
if (t < 1)
|
|
return -(Math.sqrt(1 - t * t) - 1) / 2;
|
|
t -= 2;
|
|
return (Math.sqrt(1 - t * t) + 1) / 2;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/factory/createMemo.js
|
|
var import_react = __toESM(require_react());
|
|
var createMemo = function(fn) {
|
|
return function() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
return (0, import_react.useMemo)(function() {
|
|
return fn.apply(void 0, args);
|
|
}, args);
|
|
};
|
|
};
|
|
var createMemo_default = createMemo;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/factory/createReducerContext.js
|
|
var import_react2 = __toESM(require_react());
|
|
var createReducerContext = function(reducer, defaultInitialState) {
|
|
var context = (0, import_react2.createContext)(void 0);
|
|
var providerFactory = function(props, children) {
|
|
return (0, import_react2.createElement)(context.Provider, props, children);
|
|
};
|
|
var ReducerProvider = function(_a) {
|
|
var children = _a.children, initialState = _a.initialState;
|
|
var state = (0, import_react2.useReducer)(reducer, initialState !== void 0 ? initialState : defaultInitialState);
|
|
return providerFactory({ value: state }, children);
|
|
};
|
|
var useReducerContext = function() {
|
|
var state = (0, import_react2.useContext)(context);
|
|
if (state == null) {
|
|
throw new Error("useReducerContext must be used inside a ReducerProvider.");
|
|
}
|
|
return state;
|
|
};
|
|
return [useReducerContext, ReducerProvider, context];
|
|
};
|
|
var createReducerContext_default = createReducerContext;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/factory/createReducer.js
|
|
var import_react5 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useUpdateEffect.js
|
|
var import_react4 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useFirstMountState.js
|
|
var import_react3 = __toESM(require_react());
|
|
function useFirstMountState() {
|
|
var isFirst = (0, import_react3.useRef)(true);
|
|
if (isFirst.current) {
|
|
isFirst.current = false;
|
|
return true;
|
|
}
|
|
return isFirst.current;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useUpdateEffect.js
|
|
var useUpdateEffect = function(effect, deps) {
|
|
var isFirstMount = useFirstMountState();
|
|
(0, import_react4.useEffect)(function() {
|
|
if (!isFirstMount) {
|
|
return effect();
|
|
}
|
|
}, deps);
|
|
};
|
|
var useUpdateEffect_default = useUpdateEffect;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/factory/createReducer.js
|
|
function composeMiddleware(chain) {
|
|
return function(context, dispatch) {
|
|
return chain.reduceRight(function(res, middleware) {
|
|
return middleware(context)(res);
|
|
}, dispatch);
|
|
};
|
|
}
|
|
var createReducer = function() {
|
|
var middlewares = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
middlewares[_i] = arguments[_i];
|
|
}
|
|
var composedMiddleware = composeMiddleware(middlewares);
|
|
return function(reducer, initialState, initializer) {
|
|
if (initializer === void 0) {
|
|
initializer = function(value) {
|
|
return value;
|
|
};
|
|
}
|
|
var ref = (0, import_react5.useRef)(initializer(initialState));
|
|
var _a = (0, import_react5.useState)(ref.current), setState = _a[1];
|
|
var dispatch = (0, import_react5.useCallback)(function(action) {
|
|
ref.current = reducer(ref.current, action);
|
|
setState(ref.current);
|
|
return action;
|
|
}, [reducer]);
|
|
var dispatchRef = (0, import_react5.useRef)(composedMiddleware({
|
|
getState: function() {
|
|
return ref.current;
|
|
},
|
|
dispatch: function() {
|
|
var args = [];
|
|
for (var _i2 = 0; _i2 < arguments.length; _i2++) {
|
|
args[_i2] = arguments[_i2];
|
|
}
|
|
return dispatchRef.current.apply(dispatchRef, args);
|
|
}
|
|
}, dispatch));
|
|
useUpdateEffect_default(function() {
|
|
dispatchRef.current = composedMiddleware({
|
|
getState: function() {
|
|
return ref.current;
|
|
},
|
|
dispatch: function() {
|
|
var args = [];
|
|
for (var _i2 = 0; _i2 < arguments.length; _i2++) {
|
|
args[_i2] = arguments[_i2];
|
|
}
|
|
return dispatchRef.current.apply(dispatchRef, args);
|
|
}
|
|
}, dispatch);
|
|
}, [dispatch]);
|
|
return [ref.current, dispatchRef.current];
|
|
};
|
|
};
|
|
var createReducer_default = createReducer;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/factory/createStateContext.js
|
|
var import_react6 = __toESM(require_react());
|
|
var createStateContext = function(defaultInitialValue) {
|
|
var context = (0, import_react6.createContext)(void 0);
|
|
var providerFactory = function(props, children) {
|
|
return (0, import_react6.createElement)(context.Provider, props, children);
|
|
};
|
|
var StateProvider = function(_a) {
|
|
var children = _a.children, initialValue = _a.initialValue;
|
|
var state = (0, import_react6.useState)(initialValue !== void 0 ? initialValue : defaultInitialValue);
|
|
return providerFactory({ value: state }, children);
|
|
};
|
|
var useStateContext = function() {
|
|
var state = (0, import_react6.useContext)(context);
|
|
if (state == null) {
|
|
throw new Error("useStateContext must be used inside a StateProvider.");
|
|
}
|
|
return state;
|
|
};
|
|
return [useStateContext, StateProvider, context];
|
|
};
|
|
var createStateContext_default = createStateContext;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useAsync.js
|
|
var import_react9 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useAsyncFn.js
|
|
init_tslib_es6();
|
|
var import_react8 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMountedState.js
|
|
var import_react7 = __toESM(require_react());
|
|
function useMountedState() {
|
|
var mountedRef = (0, import_react7.useRef)(false);
|
|
var get = (0, import_react7.useCallback)(function() {
|
|
return mountedRef.current;
|
|
}, []);
|
|
(0, import_react7.useEffect)(function() {
|
|
mountedRef.current = true;
|
|
return function() {
|
|
mountedRef.current = false;
|
|
};
|
|
}, []);
|
|
return get;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useAsyncFn.js
|
|
function useAsyncFn(fn, deps, initialState) {
|
|
if (deps === void 0) {
|
|
deps = [];
|
|
}
|
|
if (initialState === void 0) {
|
|
initialState = { loading: false };
|
|
}
|
|
var lastCallId = (0, import_react8.useRef)(0);
|
|
var isMounted = useMountedState();
|
|
var _a = (0, import_react8.useState)(initialState), state = _a[0], set = _a[1];
|
|
var callback = (0, import_react8.useCallback)(function() {
|
|
var args = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
args[_i] = arguments[_i];
|
|
}
|
|
var callId = ++lastCallId.current;
|
|
if (!state.loading) {
|
|
set(function(prevState) {
|
|
return __assign(__assign({}, prevState), { loading: true });
|
|
});
|
|
}
|
|
return fn.apply(void 0, args).then(function(value) {
|
|
isMounted() && callId === lastCallId.current && set({ value, loading: false });
|
|
return value;
|
|
}, function(error) {
|
|
isMounted() && callId === lastCallId.current && set({ error, loading: false });
|
|
return error;
|
|
});
|
|
}, deps);
|
|
return [state, callback];
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useAsync.js
|
|
function useAsync(fn, deps) {
|
|
if (deps === void 0) {
|
|
deps = [];
|
|
}
|
|
var _a = useAsyncFn(fn, deps, {
|
|
loading: true
|
|
}), state = _a[0], callback = _a[1];
|
|
(0, import_react9.useEffect)(function() {
|
|
callback();
|
|
}, [callback]);
|
|
return state;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useAsyncRetry.js
|
|
init_tslib_es6();
|
|
var import_react10 = __toESM(require_react());
|
|
var useAsyncRetry = function(fn, deps) {
|
|
if (deps === void 0) {
|
|
deps = [];
|
|
}
|
|
var _a = (0, import_react10.useState)(0), attempt = _a[0], setAttempt = _a[1];
|
|
var state = useAsync(fn, __spreadArrays(deps, [attempt]));
|
|
var stateLoading = state.loading;
|
|
var retry = (0, import_react10.useCallback)(function() {
|
|
if (stateLoading) {
|
|
if (true) {
|
|
console.log("You are calling useAsyncRetry hook retry() method while loading in progress, this is a no-op.");
|
|
}
|
|
return;
|
|
}
|
|
setAttempt(function(currentAttempt) {
|
|
return currentAttempt + 1;
|
|
});
|
|
}, __spreadArrays(deps, [stateLoading]));
|
|
return __assign(__assign({}, state), { retry });
|
|
};
|
|
var useAsyncRetry_default = useAsyncRetry;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/factory/createHTMLMediaHook.js
|
|
init_tslib_es6();
|
|
var React = __toESM(require_react());
|
|
var import_react12 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useSetState.js
|
|
var import_react11 = __toESM(require_react());
|
|
var useSetState = function(initialState) {
|
|
if (initialState === void 0) {
|
|
initialState = {};
|
|
}
|
|
var _a = (0, import_react11.useState)(initialState), state = _a[0], set = _a[1];
|
|
var setState = (0, import_react11.useCallback)(function(patch) {
|
|
set(function(prevState) {
|
|
return Object.assign({}, prevState, patch instanceof Function ? patch(prevState) : patch);
|
|
});
|
|
}, []);
|
|
return [state, setState];
|
|
};
|
|
var useSetState_default = useSetState;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/misc/parseTimeRanges.js
|
|
function parseTimeRanges(ranges) {
|
|
var result = [];
|
|
for (var i = 0; i < ranges.length; i++) {
|
|
result.push({
|
|
start: ranges.start(i),
|
|
end: ranges.end(i)
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/factory/createHTMLMediaHook.js
|
|
function createHTMLMediaHook(tag) {
|
|
return function(elOrProps) {
|
|
var element;
|
|
var props;
|
|
if (React.isValidElement(elOrProps)) {
|
|
element = elOrProps;
|
|
props = element.props;
|
|
} else {
|
|
props = elOrProps;
|
|
}
|
|
var _a = useSetState_default({
|
|
buffered: [],
|
|
time: 0,
|
|
duration: 0,
|
|
paused: true,
|
|
muted: false,
|
|
volume: 1,
|
|
playing: false
|
|
}), state = _a[0], setState = _a[1];
|
|
var ref = (0, import_react12.useRef)(null);
|
|
var wrapEvent = function(userEvent, proxyEvent) {
|
|
return function(event) {
|
|
try {
|
|
proxyEvent && proxyEvent(event);
|
|
} finally {
|
|
userEvent && userEvent(event);
|
|
}
|
|
};
|
|
};
|
|
var onPlay = function() {
|
|
return setState({ paused: false });
|
|
};
|
|
var onPlaying = function() {
|
|
return setState({ playing: true });
|
|
};
|
|
var onWaiting = function() {
|
|
return setState({ playing: false });
|
|
};
|
|
var onPause = function() {
|
|
return setState({ paused: true, playing: false });
|
|
};
|
|
var onVolumeChange = function() {
|
|
var el = ref.current;
|
|
if (!el) {
|
|
return;
|
|
}
|
|
setState({
|
|
muted: el.muted,
|
|
volume: el.volume
|
|
});
|
|
};
|
|
var onDurationChange = function() {
|
|
var el = ref.current;
|
|
if (!el) {
|
|
return;
|
|
}
|
|
var duration = el.duration, buffered = el.buffered;
|
|
setState({
|
|
duration,
|
|
buffered: parseTimeRanges(buffered)
|
|
});
|
|
};
|
|
var onTimeUpdate = function() {
|
|
var el = ref.current;
|
|
if (!el) {
|
|
return;
|
|
}
|
|
setState({ time: el.currentTime });
|
|
};
|
|
var onProgress = function() {
|
|
var el = ref.current;
|
|
if (!el) {
|
|
return;
|
|
}
|
|
setState({ buffered: parseTimeRanges(el.buffered) });
|
|
};
|
|
if (element) {
|
|
element = React.cloneElement(element, __assign(__assign({ controls: false }, props), { ref, onPlay: wrapEvent(props.onPlay, onPlay), onPlaying: wrapEvent(props.onPlaying, onPlaying), onWaiting: wrapEvent(props.onWaiting, onWaiting), onPause: wrapEvent(props.onPause, onPause), onVolumeChange: wrapEvent(props.onVolumeChange, onVolumeChange), onDurationChange: wrapEvent(props.onDurationChange, onDurationChange), onTimeUpdate: wrapEvent(props.onTimeUpdate, onTimeUpdate), onProgress: wrapEvent(props.onProgress, onProgress) }));
|
|
} else {
|
|
element = React.createElement(tag, __assign(__assign({ controls: false }, props), { ref, onPlay: wrapEvent(props.onPlay, onPlay), onPlaying: wrapEvent(props.onPlaying, onPlaying), onWaiting: wrapEvent(props.onWaiting, onWaiting), onPause: wrapEvent(props.onPause, onPause), onVolumeChange: wrapEvent(props.onVolumeChange, onVolumeChange), onDurationChange: wrapEvent(props.onDurationChange, onDurationChange), onTimeUpdate: wrapEvent(props.onTimeUpdate, onTimeUpdate), onProgress: wrapEvent(props.onProgress, onProgress) }));
|
|
}
|
|
var lockPlay = false;
|
|
var controls = {
|
|
play: function() {
|
|
var el = ref.current;
|
|
if (!el) {
|
|
return void 0;
|
|
}
|
|
if (!lockPlay) {
|
|
var promise = el.play();
|
|
var isPromise = typeof promise === "object";
|
|
if (isPromise) {
|
|
lockPlay = true;
|
|
var resetLock = function() {
|
|
lockPlay = false;
|
|
};
|
|
promise.then(resetLock, resetLock);
|
|
}
|
|
return promise;
|
|
}
|
|
return void 0;
|
|
},
|
|
pause: function() {
|
|
var el = ref.current;
|
|
if (el && !lockPlay) {
|
|
return el.pause();
|
|
}
|
|
},
|
|
seek: function(time) {
|
|
var el = ref.current;
|
|
if (!el || state.duration === void 0) {
|
|
return;
|
|
}
|
|
time = Math.min(state.duration, Math.max(0, time));
|
|
el.currentTime = time;
|
|
},
|
|
volume: function(volume) {
|
|
var el = ref.current;
|
|
if (!el) {
|
|
return;
|
|
}
|
|
volume = Math.min(1, Math.max(0, volume));
|
|
el.volume = volume;
|
|
setState({ volume });
|
|
},
|
|
mute: function() {
|
|
var el = ref.current;
|
|
if (!el) {
|
|
return;
|
|
}
|
|
el.muted = true;
|
|
},
|
|
unmute: function() {
|
|
var el = ref.current;
|
|
if (!el) {
|
|
return;
|
|
}
|
|
el.muted = false;
|
|
}
|
|
};
|
|
(0, import_react12.useEffect)(function() {
|
|
var el = ref.current;
|
|
if (!el) {
|
|
if (true) {
|
|
if (tag === "audio") {
|
|
console.error("useAudio() ref to <audio> element is empty at mount. It seem you have not rendered the audio element, which it returns as the first argument const [audio] = useAudio(...).");
|
|
} else if (tag === "video") {
|
|
console.error("useVideo() ref to <video> element is empty at mount. It seem you have not rendered the video element, which it returns as the first argument const [video] = useVideo(...).");
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
setState({
|
|
volume: el.volume,
|
|
muted: el.muted,
|
|
paused: el.paused
|
|
});
|
|
if (props.autoPlay && el.paused) {
|
|
controls.play();
|
|
}
|
|
}, [props.src]);
|
|
return [element, state, controls, ref];
|
|
};
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useAudio.js
|
|
var useAudio = createHTMLMediaHook("audio");
|
|
var useAudio_default = useAudio;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useBattery.js
|
|
var import_react14 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/misc/util.js
|
|
var noop = function() {
|
|
};
|
|
function on(obj) {
|
|
var args = [];
|
|
for (var _i = 1; _i < arguments.length; _i++) {
|
|
args[_i - 1] = arguments[_i];
|
|
}
|
|
if (obj && obj.addEventListener) {
|
|
obj.addEventListener.apply(obj, args);
|
|
}
|
|
}
|
|
function off(obj) {
|
|
var args = [];
|
|
for (var _i = 1; _i < arguments.length; _i++) {
|
|
args[_i - 1] = arguments[_i];
|
|
}
|
|
if (obj && obj.removeEventListener) {
|
|
obj.removeEventListener.apply(obj, args);
|
|
}
|
|
}
|
|
var isBrowser = typeof window !== "undefined";
|
|
var isNavigator = typeof navigator !== "undefined";
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/misc/isDeepEqual.js
|
|
var import_react13 = __toESM(require_react2());
|
|
var isDeepEqual_default = import_react13.default;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useBattery.js
|
|
var nav = isNavigator ? navigator : void 0;
|
|
var isBatteryApiSupported = nav && typeof nav.getBattery === "function";
|
|
function useBatteryMock() {
|
|
return { isSupported: false };
|
|
}
|
|
function useBattery() {
|
|
var _a = (0, import_react14.useState)({ isSupported: true, fetched: false }), state = _a[0], setState = _a[1];
|
|
(0, import_react14.useEffect)(function() {
|
|
var isMounted = true;
|
|
var battery = null;
|
|
var handleChange = function() {
|
|
if (!isMounted || !battery) {
|
|
return;
|
|
}
|
|
var newState = {
|
|
isSupported: true,
|
|
fetched: true,
|
|
level: battery.level,
|
|
charging: battery.charging,
|
|
dischargingTime: battery.dischargingTime,
|
|
chargingTime: battery.chargingTime
|
|
};
|
|
!isDeepEqual_default(state, newState) && setState(newState);
|
|
};
|
|
nav.getBattery().then(function(bat) {
|
|
if (!isMounted) {
|
|
return;
|
|
}
|
|
battery = bat;
|
|
on(battery, "chargingchange", handleChange);
|
|
on(battery, "chargingtimechange", handleChange);
|
|
on(battery, "dischargingtimechange", handleChange);
|
|
on(battery, "levelchange", handleChange);
|
|
handleChange();
|
|
});
|
|
return function() {
|
|
isMounted = false;
|
|
if (battery) {
|
|
off(battery, "chargingchange", handleChange);
|
|
off(battery, "chargingtimechange", handleChange);
|
|
off(battery, "dischargingtimechange", handleChange);
|
|
off(battery, "levelchange", handleChange);
|
|
}
|
|
};
|
|
}, []);
|
|
return state;
|
|
}
|
|
var useBattery_default = isBatteryApiSupported ? useBattery : useBatteryMock;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useBeforeUnload.js
|
|
var import_react15 = __toESM(require_react());
|
|
var useBeforeUnload = function(enabled, message) {
|
|
if (enabled === void 0) {
|
|
enabled = true;
|
|
}
|
|
var handler = (0, import_react15.useCallback)(function(event) {
|
|
var finalEnabled = typeof enabled === "function" ? enabled() : true;
|
|
if (!finalEnabled) {
|
|
return;
|
|
}
|
|
event.preventDefault();
|
|
if (message) {
|
|
event.returnValue = message;
|
|
}
|
|
return message;
|
|
}, [enabled, message]);
|
|
(0, import_react15.useEffect)(function() {
|
|
if (!enabled) {
|
|
return;
|
|
}
|
|
on(window, "beforeunload", handler);
|
|
return function() {
|
|
return off(window, "beforeunload", handler);
|
|
};
|
|
}, [enabled, handler]);
|
|
};
|
|
var useBeforeUnload_default = useBeforeUnload;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useToggle.js
|
|
var import_react16 = __toESM(require_react());
|
|
var toggleReducer = function(state, nextValue) {
|
|
return typeof nextValue === "boolean" ? nextValue : !state;
|
|
};
|
|
var useToggle = function(initialValue) {
|
|
return (0, import_react16.useReducer)(toggleReducer, initialValue);
|
|
};
|
|
var useToggle_default = useToggle;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useBoolean.js
|
|
var useBoolean_default = useToggle_default;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useClickAway.js
|
|
var import_react17 = __toESM(require_react());
|
|
var defaultEvents = ["mousedown", "touchstart"];
|
|
var useClickAway = function(ref, onClickAway, events) {
|
|
if (events === void 0) {
|
|
events = defaultEvents;
|
|
}
|
|
var savedCallback = (0, import_react17.useRef)(onClickAway);
|
|
(0, import_react17.useEffect)(function() {
|
|
savedCallback.current = onClickAway;
|
|
}, [onClickAway]);
|
|
(0, import_react17.useEffect)(function() {
|
|
var handler = function(event) {
|
|
var el = ref.current;
|
|
el && !el.contains(event.target) && savedCallback.current(event);
|
|
};
|
|
for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
|
|
var eventName = events_1[_i];
|
|
on(document, eventName, handler);
|
|
}
|
|
return function() {
|
|
for (var _i2 = 0, events_2 = events; _i2 < events_2.length; _i2++) {
|
|
var eventName2 = events_2[_i2];
|
|
off(document, eventName2, handler);
|
|
}
|
|
};
|
|
}, [events, ref]);
|
|
};
|
|
var useClickAway_default = useClickAway;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useCookie.js
|
|
var import_react18 = __toESM(require_react());
|
|
var import_js_cookie = __toESM(require_js_cookie());
|
|
var useCookie = function(cookieName) {
|
|
var _a = (0, import_react18.useState)(function() {
|
|
return import_js_cookie.default.get(cookieName) || null;
|
|
}), value = _a[0], setValue = _a[1];
|
|
var updateCookie = (0, import_react18.useCallback)(function(newValue, options) {
|
|
import_js_cookie.default.set(cookieName, newValue, options);
|
|
setValue(newValue);
|
|
}, [cookieName]);
|
|
var deleteCookie = (0, import_react18.useCallback)(function() {
|
|
import_js_cookie.default.remove(cookieName);
|
|
setValue(null);
|
|
}, [cookieName]);
|
|
return [value, updateCookie, deleteCookie];
|
|
};
|
|
var useCookie_default = useCookie;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useCopyToClipboard.js
|
|
var import_copy_to_clipboard = __toESM(require_copy_to_clipboard());
|
|
var import_react19 = __toESM(require_react());
|
|
var useCopyToClipboard = function() {
|
|
var isMounted = useMountedState();
|
|
var _a = useSetState_default({
|
|
value: void 0,
|
|
error: void 0,
|
|
noUserInteraction: true
|
|
}), state = _a[0], setState = _a[1];
|
|
var copyToClipboard = (0, import_react19.useCallback)(function(value) {
|
|
if (!isMounted()) {
|
|
return;
|
|
}
|
|
var noUserInteraction;
|
|
var normalizedValue;
|
|
try {
|
|
if (typeof value !== "string" && typeof value !== "number") {
|
|
var error = new Error("Cannot copy typeof " + typeof value + " to clipboard, must be a string");
|
|
if (true)
|
|
console.error(error);
|
|
setState({
|
|
value,
|
|
error,
|
|
noUserInteraction: true
|
|
});
|
|
return;
|
|
} else if (value === "") {
|
|
var error = new Error("Cannot copy empty string to clipboard.");
|
|
if (true)
|
|
console.error(error);
|
|
setState({
|
|
value,
|
|
error,
|
|
noUserInteraction: true
|
|
});
|
|
return;
|
|
}
|
|
normalizedValue = value.toString();
|
|
noUserInteraction = (0, import_copy_to_clipboard.default)(normalizedValue);
|
|
setState({
|
|
value: normalizedValue,
|
|
error: void 0,
|
|
noUserInteraction
|
|
});
|
|
} catch (error2) {
|
|
setState({
|
|
value: normalizedValue,
|
|
error: error2,
|
|
noUserInteraction
|
|
});
|
|
}
|
|
}, []);
|
|
return [state, copyToClipboard];
|
|
};
|
|
var useCopyToClipboard_default = useCopyToClipboard;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useCounter.js
|
|
var import_react22 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useGetSet.js
|
|
var import_react21 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useUpdate.js
|
|
var import_react20 = __toESM(require_react());
|
|
var updateReducer = function(num) {
|
|
return (num + 1) % 1e6;
|
|
};
|
|
function useUpdate() {
|
|
var _a = (0, import_react20.useReducer)(updateReducer, 0), update = _a[1];
|
|
return update;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/misc/hookState.js
|
|
function resolveHookState(nextState, currentState) {
|
|
if (typeof nextState === "function") {
|
|
return nextState.length ? nextState(currentState) : nextState();
|
|
}
|
|
return nextState;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useGetSet.js
|
|
function useGetSet(initialState) {
|
|
var state = (0, import_react21.useRef)(resolveHookState(initialState));
|
|
var update = useUpdate();
|
|
return (0, import_react21.useMemo)(function() {
|
|
return [
|
|
function() {
|
|
return state.current;
|
|
},
|
|
function(newState) {
|
|
state.current = resolveHookState(newState, state.current);
|
|
update();
|
|
}
|
|
];
|
|
}, []);
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useCounter.js
|
|
function useCounter(initialValue, max, min) {
|
|
if (initialValue === void 0) {
|
|
initialValue = 0;
|
|
}
|
|
if (max === void 0) {
|
|
max = null;
|
|
}
|
|
if (min === void 0) {
|
|
min = null;
|
|
}
|
|
var init = resolveHookState(initialValue);
|
|
typeof init !== "number" && console.error("initialValue has to be a number, got " + typeof initialValue);
|
|
if (typeof min === "number") {
|
|
init = Math.max(init, min);
|
|
} else if (min !== null) {
|
|
console.error("min has to be a number, got " + typeof min);
|
|
}
|
|
if (typeof max === "number") {
|
|
init = Math.min(init, max);
|
|
} else if (max !== null) {
|
|
console.error("max has to be a number, got " + typeof max);
|
|
}
|
|
var _a = useGetSet(init), get = _a[0], setInternal = _a[1];
|
|
return [
|
|
get(),
|
|
(0, import_react22.useMemo)(function() {
|
|
var set = function(newState) {
|
|
var prevState = get();
|
|
var rState = resolveHookState(newState, prevState);
|
|
if (prevState !== rState) {
|
|
if (typeof min === "number") {
|
|
rState = Math.max(rState, min);
|
|
}
|
|
if (typeof max === "number") {
|
|
rState = Math.min(rState, max);
|
|
}
|
|
prevState !== rState && setInternal(rState);
|
|
}
|
|
};
|
|
return {
|
|
get,
|
|
set,
|
|
inc: function(delta) {
|
|
if (delta === void 0) {
|
|
delta = 1;
|
|
}
|
|
var rDelta = resolveHookState(delta, get());
|
|
if (typeof rDelta !== "number") {
|
|
console.error("delta has to be a number or function returning a number, got " + typeof rDelta);
|
|
}
|
|
set(function(num) {
|
|
return num + rDelta;
|
|
});
|
|
},
|
|
dec: function(delta) {
|
|
if (delta === void 0) {
|
|
delta = 1;
|
|
}
|
|
var rDelta = resolveHookState(delta, get());
|
|
if (typeof rDelta !== "number") {
|
|
console.error("delta has to be a number or function returning a number, got " + typeof rDelta);
|
|
}
|
|
set(function(num) {
|
|
return num - rDelta;
|
|
});
|
|
},
|
|
reset: function(value) {
|
|
if (value === void 0) {
|
|
value = init;
|
|
}
|
|
var rValue = resolveHookState(value, get());
|
|
if (typeof rValue !== "number") {
|
|
console.error("value has to be a number or function returning a number, got " + typeof rValue);
|
|
}
|
|
init = rValue;
|
|
set(rValue);
|
|
}
|
|
};
|
|
}, [init, min, max])
|
|
];
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useCss.js
|
|
var import_nano_css = __toESM(require_nano_css());
|
|
var import_cssom = __toESM(require_cssom());
|
|
var import_vcssom = __toESM(require_vcssom());
|
|
var import_cssToTree = __toESM(require_cssToTree());
|
|
var import_react24 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useIsomorphicLayoutEffect.js
|
|
var import_react23 = __toESM(require_react());
|
|
var useIsomorphicLayoutEffect = isBrowser ? import_react23.useLayoutEffect : import_react23.useEffect;
|
|
var useIsomorphicLayoutEffect_default = useIsomorphicLayoutEffect;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useCss.js
|
|
var nano = (0, import_nano_css.create)();
|
|
(0, import_cssom.addon)(nano);
|
|
(0, import_vcssom.addon)(nano);
|
|
var counter = 0;
|
|
var useCss = function(css) {
|
|
var className = (0, import_react24.useMemo)(function() {
|
|
return "react-use-css-" + (counter++).toString(36);
|
|
}, []);
|
|
var sheet = (0, import_react24.useMemo)(function() {
|
|
return new nano.VSheet();
|
|
}, []);
|
|
useIsomorphicLayoutEffect_default(function() {
|
|
var tree = {};
|
|
(0, import_cssToTree.cssToTree)(tree, css, "." + className, "");
|
|
sheet.diff(tree);
|
|
return function() {
|
|
sheet.diff({});
|
|
};
|
|
});
|
|
return className;
|
|
};
|
|
var useCss_default = useCss;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useCustomCompareEffect.js
|
|
var import_react25 = __toESM(require_react());
|
|
var isPrimitive = function(val) {
|
|
return val !== Object(val);
|
|
};
|
|
var useCustomCompareEffect = function(effect, deps, depsEqual) {
|
|
if (true) {
|
|
if (!(deps instanceof Array) || !deps.length) {
|
|
console.warn("`useCustomCompareEffect` should not be used with no dependencies. Use React.useEffect instead.");
|
|
}
|
|
if (deps.every(isPrimitive)) {
|
|
console.warn("`useCustomCompareEffect` should not be used with dependencies that are all primitive values. Use React.useEffect instead.");
|
|
}
|
|
if (typeof depsEqual !== "function") {
|
|
console.warn("`useCustomCompareEffect` should be used with depsEqual callback for comparing deps list");
|
|
}
|
|
}
|
|
var ref = (0, import_react25.useRef)(void 0);
|
|
if (!ref.current || !depsEqual(deps, ref.current)) {
|
|
ref.current = deps;
|
|
}
|
|
(0, import_react25.useEffect)(effect, ref.current);
|
|
};
|
|
var useCustomCompareEffect_default = useCustomCompareEffect;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useDebounce.js
|
|
var import_react27 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useTimeoutFn.js
|
|
var import_react26 = __toESM(require_react());
|
|
function useTimeoutFn(fn, ms) {
|
|
if (ms === void 0) {
|
|
ms = 0;
|
|
}
|
|
var ready = (0, import_react26.useRef)(false);
|
|
var timeout = (0, import_react26.useRef)();
|
|
var callback = (0, import_react26.useRef)(fn);
|
|
var isReady = (0, import_react26.useCallback)(function() {
|
|
return ready.current;
|
|
}, []);
|
|
var set = (0, import_react26.useCallback)(function() {
|
|
ready.current = false;
|
|
timeout.current && clearTimeout(timeout.current);
|
|
timeout.current = setTimeout(function() {
|
|
ready.current = true;
|
|
callback.current();
|
|
}, ms);
|
|
}, [ms]);
|
|
var clear = (0, import_react26.useCallback)(function() {
|
|
ready.current = null;
|
|
timeout.current && clearTimeout(timeout.current);
|
|
}, []);
|
|
(0, import_react26.useEffect)(function() {
|
|
callback.current = fn;
|
|
}, [fn]);
|
|
(0, import_react26.useEffect)(function() {
|
|
set();
|
|
return clear;
|
|
}, [ms]);
|
|
return [isReady, clear, set];
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useDebounce.js
|
|
function useDebounce(fn, ms, deps) {
|
|
if (ms === void 0) {
|
|
ms = 0;
|
|
}
|
|
if (deps === void 0) {
|
|
deps = [];
|
|
}
|
|
var _a = useTimeoutFn(fn, ms), isReady = _a[0], cancel = _a[1], reset = _a[2];
|
|
(0, import_react27.useEffect)(reset, deps);
|
|
return [isReady, cancel];
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useDeepCompareEffect.js
|
|
var isPrimitive2 = function(val) {
|
|
return val !== Object(val);
|
|
};
|
|
var useDeepCompareEffect = function(effect, deps) {
|
|
if (true) {
|
|
if (!(deps instanceof Array) || !deps.length) {
|
|
console.warn("`useDeepCompareEffect` should not be used with no dependencies. Use React.useEffect instead.");
|
|
}
|
|
if (deps.every(isPrimitive2)) {
|
|
console.warn("`useDeepCompareEffect` should not be used with dependencies that are all primitive values. Use React.useEffect instead.");
|
|
}
|
|
}
|
|
useCustomCompareEffect_default(effect, deps, isDeepEqual_default);
|
|
};
|
|
var useDeepCompareEffect_default = useDeepCompareEffect;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useDefault.js
|
|
var import_react28 = __toESM(require_react());
|
|
var useDefault = function(defaultValue, initialValue) {
|
|
var _a = (0, import_react28.useState)(initialValue), value = _a[0], setValue = _a[1];
|
|
if (value === void 0 || value === null) {
|
|
return [defaultValue, setValue];
|
|
}
|
|
return [value, setValue];
|
|
};
|
|
var useDefault_default = useDefault;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useDrop.js
|
|
init_tslib_es6();
|
|
var import_react29 = __toESM(require_react());
|
|
var createProcess = function(options) {
|
|
return function(dataTransfer, event) {
|
|
var uri = dataTransfer.getData("text/uri-list");
|
|
if (uri) {
|
|
(options.onUri || noop)(uri, event);
|
|
return;
|
|
}
|
|
if (dataTransfer.files && dataTransfer.files.length) {
|
|
(options.onFiles || noop)(Array.from(dataTransfer.files), event);
|
|
return;
|
|
}
|
|
if (event.clipboardData) {
|
|
var text = event.clipboardData.getData("text");
|
|
(options.onText || noop)(text, event);
|
|
return;
|
|
}
|
|
};
|
|
};
|
|
var useDrop = function(options, args) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
if (args === void 0) {
|
|
args = [];
|
|
}
|
|
var onFiles = options.onFiles, onText = options.onText, onUri = options.onUri;
|
|
var _a = (0, import_react29.useState)(false), over = _a[0], setOverRaw = _a[1];
|
|
var setOver = (0, import_react29.useCallback)(setOverRaw, []);
|
|
var process2 = (0, import_react29.useMemo)(function() {
|
|
return createProcess(options);
|
|
}, [onFiles, onText, onUri]);
|
|
(0, import_react29.useEffect)(function() {
|
|
var onDragOver = function(event) {
|
|
event.preventDefault();
|
|
setOver(true);
|
|
};
|
|
var onDragEnter = function(event) {
|
|
event.preventDefault();
|
|
setOver(true);
|
|
};
|
|
var onDragLeave = function() {
|
|
setOver(false);
|
|
};
|
|
var onDragExit = function() {
|
|
setOver(false);
|
|
};
|
|
var onDrop = function(event) {
|
|
event.preventDefault();
|
|
setOver(false);
|
|
process2(event.dataTransfer, event);
|
|
};
|
|
var onPaste = function(event) {
|
|
process2(event.clipboardData, event);
|
|
};
|
|
on(document, "dragover", onDragOver);
|
|
on(document, "dragenter", onDragEnter);
|
|
on(document, "dragleave", onDragLeave);
|
|
on(document, "dragexit", onDragExit);
|
|
on(document, "drop", onDrop);
|
|
if (onText) {
|
|
on(document, "paste", onPaste);
|
|
}
|
|
return function() {
|
|
off(document, "dragover", onDragOver);
|
|
off(document, "dragenter", onDragEnter);
|
|
off(document, "dragleave", onDragLeave);
|
|
off(document, "dragexit", onDragExit);
|
|
off(document, "drop", onDrop);
|
|
off(document, "paste", onPaste);
|
|
};
|
|
}, __spreadArrays([process2], args));
|
|
return { over };
|
|
};
|
|
var useDrop_default = useDrop;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useDropArea.js
|
|
var import_react30 = __toESM(require_react());
|
|
var createProcess2 = function(options, mounted) {
|
|
return function(dataTransfer, event) {
|
|
var uri = dataTransfer.getData("text/uri-list");
|
|
if (uri) {
|
|
(options.onUri || noop)(uri, event);
|
|
return;
|
|
}
|
|
if (dataTransfer.files && dataTransfer.files.length) {
|
|
(options.onFiles || noop)(Array.from(dataTransfer.files), event);
|
|
return;
|
|
}
|
|
if (dataTransfer.items && dataTransfer.items.length) {
|
|
dataTransfer.items[0].getAsString(function(text) {
|
|
if (mounted) {
|
|
(options.onText || noop)(text, event);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
};
|
|
var createBond = function(process2, setOver) {
|
|
return {
|
|
onDragOver: function(event) {
|
|
event.preventDefault();
|
|
},
|
|
onDragEnter: function(event) {
|
|
event.preventDefault();
|
|
setOver(true);
|
|
},
|
|
onDragLeave: function() {
|
|
setOver(false);
|
|
},
|
|
onDrop: function(event) {
|
|
event.preventDefault();
|
|
event.persist();
|
|
setOver(false);
|
|
process2(event.dataTransfer, event);
|
|
},
|
|
onPaste: function(event) {
|
|
event.persist();
|
|
process2(event.clipboardData, event);
|
|
}
|
|
};
|
|
};
|
|
var useDropArea = function(options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
var onFiles = options.onFiles, onText = options.onText, onUri = options.onUri;
|
|
var isMounted = useMountedState();
|
|
var _a = (0, import_react30.useState)(false), over = _a[0], setOver = _a[1];
|
|
var process2 = (0, import_react30.useMemo)(function() {
|
|
return createProcess2(options, isMounted());
|
|
}, [onFiles, onText, onUri]);
|
|
var bond = (0, import_react30.useMemo)(function() {
|
|
return createBond(process2, setOver);
|
|
}, [process2, setOver]);
|
|
return [bond, { over }];
|
|
};
|
|
var useDropArea_default = useDropArea;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useEffectOnce.js
|
|
var import_react31 = __toESM(require_react());
|
|
var useEffectOnce = function(effect) {
|
|
(0, import_react31.useEffect)(effect, []);
|
|
};
|
|
var useEffectOnce_default = useEffectOnce;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useEnsuredForwardedRef.js
|
|
var import_react32 = __toESM(require_react());
|
|
function useEnsuredForwardedRef(forwardedRef) {
|
|
var ensuredRef = (0, import_react32.useRef)(forwardedRef && forwardedRef.current);
|
|
(0, import_react32.useEffect)(function() {
|
|
if (!forwardedRef) {
|
|
return;
|
|
}
|
|
forwardedRef.current = ensuredRef.current;
|
|
}, [forwardedRef]);
|
|
return ensuredRef;
|
|
}
|
|
function ensuredForwardRef(Component) {
|
|
return (0, import_react32.forwardRef)(function(props, ref) {
|
|
var ensuredRef = useEnsuredForwardedRef(ref);
|
|
return Component(props, ensuredRef);
|
|
});
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useEvent.js
|
|
var import_react33 = __toESM(require_react());
|
|
var defaultTarget = isBrowser ? window : null;
|
|
var isListenerType1 = function(target) {
|
|
return !!target.addEventListener;
|
|
};
|
|
var isListenerType2 = function(target) {
|
|
return !!target.on;
|
|
};
|
|
var useEvent = function(name, handler, target, options) {
|
|
if (target === void 0) {
|
|
target = defaultTarget;
|
|
}
|
|
(0, import_react33.useEffect)(function() {
|
|
if (!handler) {
|
|
return;
|
|
}
|
|
if (!target) {
|
|
return;
|
|
}
|
|
if (isListenerType1(target)) {
|
|
on(target, name, handler, options);
|
|
} else if (isListenerType2(target)) {
|
|
target.on(name, handler, options);
|
|
}
|
|
return function() {
|
|
if (isListenerType1(target)) {
|
|
off(target, name, handler, options);
|
|
} else if (isListenerType2(target)) {
|
|
target.off(name, handler, options);
|
|
}
|
|
};
|
|
}, [name, handler, target, JSON.stringify(options)]);
|
|
};
|
|
var useEvent_default = useEvent;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useError.js
|
|
var import_react34 = __toESM(require_react());
|
|
var useError = function() {
|
|
var _a = (0, import_react34.useState)(null), error = _a[0], setError = _a[1];
|
|
(0, import_react34.useEffect)(function() {
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
}, [error]);
|
|
var dispatchError = (0, import_react34.useCallback)(function(err) {
|
|
setError(err);
|
|
}, []);
|
|
return dispatchError;
|
|
};
|
|
var useError_default = useError;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useFavicon.js
|
|
var import_react35 = __toESM(require_react());
|
|
var useFavicon = function(href) {
|
|
(0, import_react35.useEffect)(function() {
|
|
var link = document.querySelector("link[rel*='icon']") || document.createElement("link");
|
|
link.type = "image/x-icon";
|
|
link.rel = "shortcut icon";
|
|
link.href = href;
|
|
document.getElementsByTagName("head")[0].appendChild(link);
|
|
}, [href]);
|
|
};
|
|
var useFavicon_default = useFavicon;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useFullscreen.js
|
|
var import_react36 = __toESM(require_react());
|
|
var import_screenfull = __toESM(require_screenfull());
|
|
var useFullscreen = function(ref, enabled, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
var video = options.video, _a = options.onClose, onClose = _a === void 0 ? noop : _a;
|
|
var _b = (0, import_react36.useState)(enabled), isFullscreen = _b[0], setIsFullscreen = _b[1];
|
|
useIsomorphicLayoutEffect_default(function() {
|
|
if (!enabled) {
|
|
return;
|
|
}
|
|
if (!ref.current) {
|
|
return;
|
|
}
|
|
var onWebkitEndFullscreen = function() {
|
|
if (video === null || video === void 0 ? void 0 : video.current) {
|
|
off(video.current, "webkitendfullscreen", onWebkitEndFullscreen);
|
|
}
|
|
onClose();
|
|
};
|
|
var onChange = function() {
|
|
if (import_screenfull.default.isEnabled) {
|
|
var isScreenfullFullscreen = import_screenfull.default.isFullscreen;
|
|
setIsFullscreen(isScreenfullFullscreen);
|
|
if (!isScreenfullFullscreen) {
|
|
onClose();
|
|
}
|
|
}
|
|
};
|
|
if (import_screenfull.default.isEnabled) {
|
|
try {
|
|
import_screenfull.default.request(ref.current);
|
|
setIsFullscreen(true);
|
|
} catch (error) {
|
|
onClose(error);
|
|
setIsFullscreen(false);
|
|
}
|
|
import_screenfull.default.on("change", onChange);
|
|
} else if (video && video.current && video.current.webkitEnterFullscreen) {
|
|
video.current.webkitEnterFullscreen();
|
|
on(video.current, "webkitendfullscreen", onWebkitEndFullscreen);
|
|
setIsFullscreen(true);
|
|
} else {
|
|
onClose();
|
|
setIsFullscreen(false);
|
|
}
|
|
return function() {
|
|
setIsFullscreen(false);
|
|
if (import_screenfull.default.isEnabled) {
|
|
try {
|
|
import_screenfull.default.off("change", onChange);
|
|
import_screenfull.default.exit();
|
|
} catch (_a2) {
|
|
}
|
|
} else if (video && video.current && video.current.webkitExitFullscreen) {
|
|
off(video.current, "webkitendfullscreen", onWebkitEndFullscreen);
|
|
video.current.webkitExitFullscreen();
|
|
}
|
|
};
|
|
}, [enabled, video, ref]);
|
|
return isFullscreen;
|
|
};
|
|
var useFullscreen_default = useFullscreen;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useGeolocation.js
|
|
init_tslib_es6();
|
|
var import_react37 = __toESM(require_react());
|
|
var useGeolocation = function(options) {
|
|
var _a = (0, import_react37.useState)({
|
|
loading: true,
|
|
accuracy: null,
|
|
altitude: null,
|
|
altitudeAccuracy: null,
|
|
heading: null,
|
|
latitude: null,
|
|
longitude: null,
|
|
speed: null,
|
|
timestamp: Date.now()
|
|
}), state = _a[0], setState = _a[1];
|
|
var mounted = true;
|
|
var watchId;
|
|
var onEvent = function(event) {
|
|
if (mounted) {
|
|
setState({
|
|
loading: false,
|
|
accuracy: event.coords.accuracy,
|
|
altitude: event.coords.altitude,
|
|
altitudeAccuracy: event.coords.altitudeAccuracy,
|
|
heading: event.coords.heading,
|
|
latitude: event.coords.latitude,
|
|
longitude: event.coords.longitude,
|
|
speed: event.coords.speed,
|
|
timestamp: event.timestamp
|
|
});
|
|
}
|
|
};
|
|
var onEventError = function(error) {
|
|
return mounted && setState(function(oldState) {
|
|
return __assign(__assign({}, oldState), { loading: false, error });
|
|
});
|
|
};
|
|
(0, import_react37.useEffect)(function() {
|
|
navigator.geolocation.getCurrentPosition(onEvent, onEventError, options);
|
|
watchId = navigator.geolocation.watchPosition(onEvent, onEventError, options);
|
|
return function() {
|
|
mounted = false;
|
|
navigator.geolocation.clearWatch(watchId);
|
|
};
|
|
}, []);
|
|
return state;
|
|
};
|
|
var useGeolocation_default = useGeolocation;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useGetSetState.js
|
|
init_tslib_es6();
|
|
var import_react38 = __toESM(require_react());
|
|
var useGetSetState = function(initialState) {
|
|
if (initialState === void 0) {
|
|
initialState = {};
|
|
}
|
|
if (true) {
|
|
if (typeof initialState !== "object") {
|
|
console.error("useGetSetState initial state must be an object.");
|
|
}
|
|
}
|
|
var update = useUpdate();
|
|
var state = (0, import_react38.useRef)(__assign({}, initialState));
|
|
var get = (0, import_react38.useCallback)(function() {
|
|
return state.current;
|
|
}, []);
|
|
var set = (0, import_react38.useCallback)(function(patch) {
|
|
if (!patch) {
|
|
return;
|
|
}
|
|
if (true) {
|
|
if (typeof patch !== "object") {
|
|
console.error("useGetSetState setter patch must be an object.");
|
|
}
|
|
}
|
|
Object.assign(state.current, patch);
|
|
update();
|
|
}, []);
|
|
return [get, set];
|
|
};
|
|
var useGetSetState_default = useGetSetState;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useHarmonicIntervalFn.js
|
|
var import_react39 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/set-harmonic-interval@1.0.1/node_modules/set-harmonic-interval/lib/index.esm.js
|
|
var counter2 = 0;
|
|
var buckets = {};
|
|
var setHarmonicInterval = function(fn, ms) {
|
|
var _a;
|
|
var id = counter2++;
|
|
if (buckets[ms]) {
|
|
buckets[ms].listeners[id] = fn;
|
|
} else {
|
|
var timer = setInterval(function() {
|
|
var listeners = buckets[ms].listeners;
|
|
var didThrow = false;
|
|
var lastError;
|
|
for (var _i = 0, _a2 = Object.values(listeners); _i < _a2.length; _i++) {
|
|
var listener = _a2[_i];
|
|
try {
|
|
listener();
|
|
} catch (error) {
|
|
didThrow = true;
|
|
lastError = error;
|
|
}
|
|
}
|
|
if (didThrow)
|
|
throw lastError;
|
|
}, ms);
|
|
buckets[ms] = {
|
|
ms,
|
|
timer,
|
|
listeners: (_a = {}, _a[id] = fn, _a)
|
|
};
|
|
}
|
|
return {
|
|
bucket: buckets[ms],
|
|
id
|
|
};
|
|
};
|
|
var clearHarmonicInterval = function(_a) {
|
|
var bucket = _a.bucket, id = _a.id;
|
|
delete bucket.listeners[id];
|
|
var hasListeners = false;
|
|
for (var listener in bucket.listeners) {
|
|
hasListeners = true;
|
|
break;
|
|
}
|
|
if (!hasListeners) {
|
|
clearInterval(bucket.timer);
|
|
delete buckets[bucket.ms];
|
|
}
|
|
};
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useHarmonicIntervalFn.js
|
|
var useHarmonicIntervalFn = function(fn, delay) {
|
|
if (delay === void 0) {
|
|
delay = 0;
|
|
}
|
|
var latestCallback = (0, import_react39.useRef)(function() {
|
|
});
|
|
(0, import_react39.useEffect)(function() {
|
|
latestCallback.current = fn;
|
|
});
|
|
(0, import_react39.useEffect)(function() {
|
|
if (delay !== null) {
|
|
var interval_1 = setHarmonicInterval(function() {
|
|
return latestCallback.current();
|
|
}, delay);
|
|
return function() {
|
|
return clearHarmonicInterval(interval_1);
|
|
};
|
|
}
|
|
return void 0;
|
|
}, [delay]);
|
|
};
|
|
var useHarmonicIntervalFn_default = useHarmonicIntervalFn;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useHover.js
|
|
var React2 = __toESM(require_react());
|
|
var useState15 = React2.useState;
|
|
var useHover = function(element) {
|
|
var _a = useState15(false), state = _a[0], setState = _a[1];
|
|
var onMouseEnter = function(originalOnMouseEnter) {
|
|
return function(event) {
|
|
(originalOnMouseEnter || noop)(event);
|
|
setState(true);
|
|
};
|
|
};
|
|
var onMouseLeave = function(originalOnMouseLeave) {
|
|
return function(event) {
|
|
(originalOnMouseLeave || noop)(event);
|
|
setState(false);
|
|
};
|
|
};
|
|
if (typeof element === "function") {
|
|
element = element(state);
|
|
}
|
|
var el = React2.cloneElement(element, {
|
|
onMouseEnter: onMouseEnter(element.props.onMouseEnter),
|
|
onMouseLeave: onMouseLeave(element.props.onMouseLeave)
|
|
});
|
|
return [el, state];
|
|
};
|
|
var useHover_default = useHover;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useHoverDirty.js
|
|
var import_react40 = __toESM(require_react());
|
|
var useHoverDirty = function(ref, enabled) {
|
|
if (enabled === void 0) {
|
|
enabled = true;
|
|
}
|
|
if (true) {
|
|
if (typeof ref !== "object" || typeof ref.current === "undefined") {
|
|
console.error("useHoverDirty expects a single ref argument.");
|
|
}
|
|
}
|
|
var _a = (0, import_react40.useState)(false), value = _a[0], setValue = _a[1];
|
|
(0, import_react40.useEffect)(function() {
|
|
var onMouseOver = function() {
|
|
return setValue(true);
|
|
};
|
|
var onMouseOut = function() {
|
|
return setValue(false);
|
|
};
|
|
if (enabled && ref && ref.current) {
|
|
on(ref.current, "mouseover", onMouseOver);
|
|
on(ref.current, "mouseout", onMouseOut);
|
|
}
|
|
var current = ref.current;
|
|
return function() {
|
|
if (enabled && current) {
|
|
off(current, "mouseover", onMouseOver);
|
|
off(current, "mouseout", onMouseOut);
|
|
}
|
|
};
|
|
}, [enabled, ref]);
|
|
return value;
|
|
};
|
|
var useHoverDirty_default = useHoverDirty;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useIdle.js
|
|
var import_react41 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/throttle-debounce@3.0.1/node_modules/throttle-debounce/esm/index.js
|
|
function throttle(delay, noTrailing, callback, debounceMode) {
|
|
var timeoutID;
|
|
var cancelled = false;
|
|
var lastExec = 0;
|
|
function clearExistingTimeout() {
|
|
if (timeoutID) {
|
|
clearTimeout(timeoutID);
|
|
}
|
|
}
|
|
function cancel() {
|
|
clearExistingTimeout();
|
|
cancelled = true;
|
|
}
|
|
if (typeof noTrailing !== "boolean") {
|
|
debounceMode = callback;
|
|
callback = noTrailing;
|
|
noTrailing = void 0;
|
|
}
|
|
function wrapper() {
|
|
for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
arguments_[_key] = arguments[_key];
|
|
}
|
|
var self = this;
|
|
var elapsed = Date.now() - lastExec;
|
|
if (cancelled) {
|
|
return;
|
|
}
|
|
function exec() {
|
|
lastExec = Date.now();
|
|
callback.apply(self, arguments_);
|
|
}
|
|
function clear() {
|
|
timeoutID = void 0;
|
|
}
|
|
if (debounceMode && !timeoutID) {
|
|
exec();
|
|
}
|
|
clearExistingTimeout();
|
|
if (debounceMode === void 0 && elapsed > delay) {
|
|
exec();
|
|
} else if (noTrailing !== true) {
|
|
timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === void 0 ? delay - elapsed : delay);
|
|
}
|
|
}
|
|
wrapper.cancel = cancel;
|
|
return wrapper;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useIdle.js
|
|
var defaultEvents2 = ["mousemove", "mousedown", "resize", "keydown", "touchstart", "wheel"];
|
|
var oneMinute = 6e4;
|
|
var useIdle = function(ms, initialState, events) {
|
|
if (ms === void 0) {
|
|
ms = oneMinute;
|
|
}
|
|
if (initialState === void 0) {
|
|
initialState = false;
|
|
}
|
|
if (events === void 0) {
|
|
events = defaultEvents2;
|
|
}
|
|
var _a = (0, import_react41.useState)(initialState), state = _a[0], setState = _a[1];
|
|
(0, import_react41.useEffect)(function() {
|
|
var mounted = true;
|
|
var timeout;
|
|
var localState = state;
|
|
var set = function(newState) {
|
|
if (mounted) {
|
|
localState = newState;
|
|
setState(newState);
|
|
}
|
|
};
|
|
var onEvent = throttle(50, function() {
|
|
if (localState) {
|
|
set(false);
|
|
}
|
|
clearTimeout(timeout);
|
|
timeout = setTimeout(function() {
|
|
return set(true);
|
|
}, ms);
|
|
});
|
|
var onVisibility = function() {
|
|
if (!document.hidden) {
|
|
onEvent();
|
|
}
|
|
};
|
|
for (var i = 0; i < events.length; i++) {
|
|
on(window, events[i], onEvent);
|
|
}
|
|
on(document, "visibilitychange", onVisibility);
|
|
timeout = setTimeout(function() {
|
|
return set(true);
|
|
}, ms);
|
|
return function() {
|
|
mounted = false;
|
|
for (var i2 = 0; i2 < events.length; i2++) {
|
|
off(window, events[i2], onEvent);
|
|
}
|
|
off(document, "visibilitychange", onVisibility);
|
|
};
|
|
}, [ms, events]);
|
|
return state;
|
|
};
|
|
var useIdle_default = useIdle;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useIntersection.js
|
|
var import_react42 = __toESM(require_react());
|
|
var useIntersection = function(ref, options) {
|
|
var _a = (0, import_react42.useState)(null), intersectionObserverEntry = _a[0], setIntersectionObserverEntry = _a[1];
|
|
(0, import_react42.useEffect)(function() {
|
|
if (ref.current && typeof IntersectionObserver === "function") {
|
|
var handler = function(entries) {
|
|
setIntersectionObserverEntry(entries[0]);
|
|
};
|
|
var observer_1 = new IntersectionObserver(handler, options);
|
|
observer_1.observe(ref.current);
|
|
return function() {
|
|
setIntersectionObserverEntry(null);
|
|
observer_1.disconnect();
|
|
};
|
|
}
|
|
return function() {
|
|
};
|
|
}, [ref.current, options.threshold, options.root, options.rootMargin]);
|
|
return intersectionObserverEntry;
|
|
};
|
|
var useIntersection_default = useIntersection;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useInterval.js
|
|
var import_react43 = __toESM(require_react());
|
|
var useInterval = function(callback, delay) {
|
|
var savedCallback = (0, import_react43.useRef)(function() {
|
|
});
|
|
(0, import_react43.useEffect)(function() {
|
|
savedCallback.current = callback;
|
|
});
|
|
(0, import_react43.useEffect)(function() {
|
|
if (delay !== null) {
|
|
var interval_1 = setInterval(function() {
|
|
return savedCallback.current();
|
|
}, delay || 0);
|
|
return function() {
|
|
return clearInterval(interval_1);
|
|
};
|
|
}
|
|
return void 0;
|
|
}, [delay]);
|
|
};
|
|
var useInterval_default = useInterval;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useKey.js
|
|
var import_react44 = __toESM(require_react());
|
|
var createKeyPredicate = function(keyFilter) {
|
|
return typeof keyFilter === "function" ? keyFilter : typeof keyFilter === "string" ? function(event) {
|
|
return event.key === keyFilter;
|
|
} : keyFilter ? function() {
|
|
return true;
|
|
} : function() {
|
|
return false;
|
|
};
|
|
};
|
|
var useKey = function(key, fn, opts, deps) {
|
|
if (fn === void 0) {
|
|
fn = noop;
|
|
}
|
|
if (opts === void 0) {
|
|
opts = {};
|
|
}
|
|
if (deps === void 0) {
|
|
deps = [key];
|
|
}
|
|
var _a = opts.event, event = _a === void 0 ? "keydown" : _a, target = opts.target, options = opts.options;
|
|
var useMemoHandler = (0, import_react44.useMemo)(function() {
|
|
var predicate = createKeyPredicate(key);
|
|
var handler = function(handlerEvent) {
|
|
if (predicate(handlerEvent)) {
|
|
return fn(handlerEvent);
|
|
}
|
|
};
|
|
return handler;
|
|
}, deps);
|
|
useEvent_default(event, useMemoHandler, target, options);
|
|
};
|
|
var useKey_default = useKey;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/factory/createBreakpoint.js
|
|
var import_react45 = __toESM(require_react());
|
|
var createBreakpoint = function(breakpoints) {
|
|
if (breakpoints === void 0) {
|
|
breakpoints = { laptopL: 1440, laptop: 1024, tablet: 768 };
|
|
}
|
|
return function() {
|
|
var _a = (0, import_react45.useState)(isBrowser ? window.innerWidth : 0), screen = _a[0], setScreen = _a[1];
|
|
(0, import_react45.useEffect)(function() {
|
|
var setSideScreen = function() {
|
|
setScreen(window.innerWidth);
|
|
};
|
|
setSideScreen();
|
|
on(window, "resize", setSideScreen);
|
|
return function() {
|
|
off(window, "resize", setSideScreen);
|
|
};
|
|
});
|
|
var sortedBreakpoints = (0, import_react45.useMemo)(function() {
|
|
return Object.entries(breakpoints).sort(function(a, b) {
|
|
return a[1] >= b[1] ? 1 : -1;
|
|
});
|
|
}, [breakpoints]);
|
|
var result = sortedBreakpoints.reduce(function(acc, _a2) {
|
|
var name = _a2[0], width = _a2[1];
|
|
if (screen >= width) {
|
|
return name;
|
|
} else {
|
|
return acc;
|
|
}
|
|
}, sortedBreakpoints[0][0]);
|
|
return result;
|
|
};
|
|
};
|
|
var createBreakpoint_default = createBreakpoint;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useKeyPress.js
|
|
var import_react46 = __toESM(require_react());
|
|
var useKeyPress = function(keyFilter) {
|
|
var _a = (0, import_react46.useState)([false, null]), state = _a[0], set = _a[1];
|
|
useKey_default(keyFilter, function(event) {
|
|
return set([true, event]);
|
|
}, { event: "keydown" }, [state]);
|
|
useKey_default(keyFilter, function(event) {
|
|
return set([false, event]);
|
|
}, { event: "keyup" }, [state]);
|
|
return state;
|
|
};
|
|
var useKeyPress_default = useKeyPress;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useKeyPressEvent.js
|
|
var useKeyPressEvent = function(key, keydown, keyup, useKeyPress2) {
|
|
if (useKeyPress2 === void 0) {
|
|
useKeyPress2 = useKeyPress_default;
|
|
}
|
|
var _a = useKeyPress2(key), pressed = _a[0], event = _a[1];
|
|
useUpdateEffect_default(function() {
|
|
if (!pressed && keyup) {
|
|
keyup(event);
|
|
} else if (pressed && keydown) {
|
|
keydown(event);
|
|
}
|
|
}, [pressed]);
|
|
};
|
|
var useKeyPressEvent_default = useKeyPressEvent;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useLatest.js
|
|
var import_react47 = __toESM(require_react());
|
|
var useLatest = function(value) {
|
|
var ref = (0, import_react47.useRef)(value);
|
|
ref.current = value;
|
|
return ref;
|
|
};
|
|
var useLatest_default = useLatest;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useLifecycles.js
|
|
var import_react48 = __toESM(require_react());
|
|
var useLifecycles = function(mount, unmount) {
|
|
(0, import_react48.useEffect)(function() {
|
|
if (mount) {
|
|
mount();
|
|
}
|
|
return function() {
|
|
if (unmount) {
|
|
unmount();
|
|
}
|
|
};
|
|
}, []);
|
|
};
|
|
var useLifecycles_default = useLifecycles;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useList.js
|
|
var import_react49 = __toESM(require_react());
|
|
function useList(initialList) {
|
|
if (initialList === void 0) {
|
|
initialList = [];
|
|
}
|
|
var list = (0, import_react49.useRef)(resolveHookState(initialList));
|
|
var update = useUpdate();
|
|
var actions = (0, import_react49.useMemo)(function() {
|
|
var a = {
|
|
set: function(newList) {
|
|
list.current = resolveHookState(newList, list.current);
|
|
update();
|
|
},
|
|
push: function() {
|
|
var items = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
items[_i] = arguments[_i];
|
|
}
|
|
items.length && actions.set(function(curr) {
|
|
return curr.concat(items);
|
|
});
|
|
},
|
|
updateAt: function(index, item) {
|
|
actions.set(function(curr) {
|
|
var arr = curr.slice();
|
|
arr[index] = item;
|
|
return arr;
|
|
});
|
|
},
|
|
insertAt: function(index, item) {
|
|
actions.set(function(curr) {
|
|
var arr = curr.slice();
|
|
index > arr.length ? arr[index] = item : arr.splice(index, 0, item);
|
|
return arr;
|
|
});
|
|
},
|
|
update: function(predicate, newItem) {
|
|
actions.set(function(curr) {
|
|
return curr.map(function(item) {
|
|
return predicate(item, newItem) ? newItem : item;
|
|
});
|
|
});
|
|
},
|
|
updateFirst: function(predicate, newItem) {
|
|
var index = list.current.findIndex(function(item) {
|
|
return predicate(item, newItem);
|
|
});
|
|
index >= 0 && actions.updateAt(index, newItem);
|
|
},
|
|
upsert: function(predicate, newItem) {
|
|
var index = list.current.findIndex(function(item) {
|
|
return predicate(item, newItem);
|
|
});
|
|
index >= 0 ? actions.updateAt(index, newItem) : actions.push(newItem);
|
|
},
|
|
sort: function(compareFn) {
|
|
actions.set(function(curr) {
|
|
return curr.slice().sort(compareFn);
|
|
});
|
|
},
|
|
filter: function(callbackFn, thisArg) {
|
|
actions.set(function(curr) {
|
|
return curr.slice().filter(callbackFn, thisArg);
|
|
});
|
|
},
|
|
removeAt: function(index) {
|
|
actions.set(function(curr) {
|
|
var arr = curr.slice();
|
|
arr.splice(index, 1);
|
|
return arr;
|
|
});
|
|
},
|
|
clear: function() {
|
|
actions.set([]);
|
|
},
|
|
reset: function() {
|
|
actions.set(resolveHookState(initialList).slice());
|
|
}
|
|
};
|
|
a.remove = a.removeAt;
|
|
return a;
|
|
}, []);
|
|
return [list.current, actions];
|
|
}
|
|
var useList_default = useList;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useLocalStorage.js
|
|
var import_react50 = __toESM(require_react());
|
|
var useLocalStorage = function(key, initialValue, options) {
|
|
if (!isBrowser) {
|
|
return [initialValue, noop, noop];
|
|
}
|
|
if (!key) {
|
|
throw new Error("useLocalStorage key may not be falsy");
|
|
}
|
|
var deserializer = options ? options.raw ? function(value) {
|
|
return value;
|
|
} : options.deserializer : JSON.parse;
|
|
var initializer = (0, import_react50.useRef)(function(key2) {
|
|
try {
|
|
var serializer = options ? options.raw ? String : options.serializer : JSON.stringify;
|
|
var localStorageValue = localStorage.getItem(key2);
|
|
if (localStorageValue !== null) {
|
|
return deserializer(localStorageValue);
|
|
} else {
|
|
initialValue && localStorage.setItem(key2, serializer(initialValue));
|
|
return initialValue;
|
|
}
|
|
} catch (_a2) {
|
|
return initialValue;
|
|
}
|
|
});
|
|
var _a = (0, import_react50.useState)(function() {
|
|
return initializer.current(key);
|
|
}), state = _a[0], setState = _a[1];
|
|
(0, import_react50.useLayoutEffect)(function() {
|
|
return setState(initializer.current(key));
|
|
}, [key]);
|
|
var set = (0, import_react50.useCallback)(function(valOrFunc) {
|
|
try {
|
|
var newState = typeof valOrFunc === "function" ? valOrFunc(state) : valOrFunc;
|
|
if (typeof newState === "undefined")
|
|
return;
|
|
var value = void 0;
|
|
if (options)
|
|
if (options.raw)
|
|
if (typeof newState === "string")
|
|
value = newState;
|
|
else
|
|
value = JSON.stringify(newState);
|
|
else if (options.serializer)
|
|
value = options.serializer(newState);
|
|
else
|
|
value = JSON.stringify(newState);
|
|
else
|
|
value = JSON.stringify(newState);
|
|
localStorage.setItem(key, value);
|
|
setState(deserializer(value));
|
|
} catch (_a2) {
|
|
}
|
|
}, [key, setState]);
|
|
var remove = (0, import_react50.useCallback)(function() {
|
|
try {
|
|
localStorage.removeItem(key);
|
|
setState(void 0);
|
|
} catch (_a2) {
|
|
}
|
|
}, [key, setState]);
|
|
return [state, set, remove];
|
|
};
|
|
var useLocalStorage_default = useLocalStorage;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useLocation.js
|
|
var import_react51 = __toESM(require_react());
|
|
var patchHistoryMethod = function(method) {
|
|
var history = window.history;
|
|
var original = history[method];
|
|
history[method] = function(state) {
|
|
var result = original.apply(this, arguments);
|
|
var event = new Event(method.toLowerCase());
|
|
event.state = state;
|
|
window.dispatchEvent(event);
|
|
return result;
|
|
};
|
|
};
|
|
if (isBrowser) {
|
|
patchHistoryMethod("pushState");
|
|
patchHistoryMethod("replaceState");
|
|
}
|
|
var useLocationServer = function() {
|
|
return {
|
|
trigger: "load",
|
|
length: 1
|
|
};
|
|
};
|
|
var buildState = function(trigger) {
|
|
var _a = window.history, state = _a.state, length = _a.length;
|
|
var _b = window.location, hash = _b.hash, host = _b.host, hostname = _b.hostname, href = _b.href, origin = _b.origin, pathname = _b.pathname, port = _b.port, protocol = _b.protocol, search = _b.search;
|
|
return {
|
|
trigger,
|
|
state,
|
|
length,
|
|
hash,
|
|
host,
|
|
hostname,
|
|
href,
|
|
origin,
|
|
pathname,
|
|
port,
|
|
protocol,
|
|
search
|
|
};
|
|
};
|
|
var useLocationBrowser = function() {
|
|
var _a = (0, import_react51.useState)(buildState("load")), state = _a[0], setState = _a[1];
|
|
(0, import_react51.useEffect)(function() {
|
|
var onPopstate = function() {
|
|
return setState(buildState("popstate"));
|
|
};
|
|
var onPushstate = function() {
|
|
return setState(buildState("pushstate"));
|
|
};
|
|
var onReplacestate = function() {
|
|
return setState(buildState("replacestate"));
|
|
};
|
|
on(window, "popstate", onPopstate);
|
|
on(window, "pushstate", onPushstate);
|
|
on(window, "replacestate", onReplacestate);
|
|
return function() {
|
|
off(window, "popstate", onPopstate);
|
|
off(window, "pushstate", onPushstate);
|
|
off(window, "replacestate", onReplacestate);
|
|
};
|
|
}, []);
|
|
return state;
|
|
};
|
|
var hasEventConstructor = typeof Event === "function";
|
|
var useLocation_default = isBrowser && hasEventConstructor ? useLocationBrowser : useLocationServer;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useLockBodyScroll.js
|
|
var import_react52 = __toESM(require_react());
|
|
function getClosestBody(el) {
|
|
if (!el) {
|
|
return null;
|
|
} else if (el.tagName === "BODY") {
|
|
return el;
|
|
} else if (el.tagName === "IFRAME") {
|
|
var document_1 = el.contentDocument;
|
|
return document_1 ? document_1.body : null;
|
|
} else if (!el.offsetParent) {
|
|
return null;
|
|
}
|
|
return getClosestBody(el.offsetParent);
|
|
}
|
|
function preventDefault(rawEvent) {
|
|
var e2 = rawEvent || window.event;
|
|
if (e2.touches.length > 1)
|
|
return true;
|
|
if (e2.preventDefault)
|
|
e2.preventDefault();
|
|
return false;
|
|
}
|
|
var isIosDevice = isBrowser && window.navigator && window.navigator.platform && /iP(ad|hone|od)/.test(window.navigator.platform);
|
|
var bodies = /* @__PURE__ */ new Map();
|
|
var doc = typeof document === "object" ? document : void 0;
|
|
var documentListenerAdded = false;
|
|
var useLockBodyScroll_default = !doc ? function useLockBodyMock(_locked, _elementRef) {
|
|
if (_locked === void 0) {
|
|
_locked = true;
|
|
}
|
|
} : function useLockBody(locked, elementRef) {
|
|
if (locked === void 0) {
|
|
locked = true;
|
|
}
|
|
var bodyRef = (0, import_react52.useRef)(doc.body);
|
|
elementRef = elementRef || bodyRef;
|
|
var lock = function(body) {
|
|
var bodyInfo = bodies.get(body);
|
|
if (!bodyInfo) {
|
|
bodies.set(body, { counter: 1, initialOverflow: body.style.overflow });
|
|
if (isIosDevice) {
|
|
if (!documentListenerAdded) {
|
|
on(document, "touchmove", preventDefault, { passive: false });
|
|
documentListenerAdded = true;
|
|
}
|
|
} else {
|
|
body.style.overflow = "hidden";
|
|
}
|
|
} else {
|
|
bodies.set(body, {
|
|
counter: bodyInfo.counter + 1,
|
|
initialOverflow: bodyInfo.initialOverflow
|
|
});
|
|
}
|
|
};
|
|
var unlock = function(body) {
|
|
var bodyInfo = bodies.get(body);
|
|
if (bodyInfo) {
|
|
if (bodyInfo.counter === 1) {
|
|
bodies.delete(body);
|
|
if (isIosDevice) {
|
|
body.ontouchmove = null;
|
|
if (documentListenerAdded) {
|
|
off(document, "touchmove", preventDefault);
|
|
documentListenerAdded = false;
|
|
}
|
|
} else {
|
|
body.style.overflow = bodyInfo.initialOverflow;
|
|
}
|
|
} else {
|
|
bodies.set(body, {
|
|
counter: bodyInfo.counter - 1,
|
|
initialOverflow: bodyInfo.initialOverflow
|
|
});
|
|
}
|
|
}
|
|
};
|
|
(0, import_react52.useEffect)(function() {
|
|
var body = getClosestBody(elementRef.current);
|
|
if (!body) {
|
|
return;
|
|
}
|
|
if (locked) {
|
|
lock(body);
|
|
} else {
|
|
unlock(body);
|
|
}
|
|
}, [locked, elementRef.current]);
|
|
(0, import_react52.useEffect)(function() {
|
|
var body = getClosestBody(elementRef.current);
|
|
if (!body) {
|
|
return;
|
|
}
|
|
return function() {
|
|
unlock(body);
|
|
};
|
|
}, []);
|
|
};
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useLogger.js
|
|
init_tslib_es6();
|
|
var useLogger = function(componentName) {
|
|
var rest = [];
|
|
for (var _i = 1; _i < arguments.length; _i++) {
|
|
rest[_i - 1] = arguments[_i];
|
|
}
|
|
useEffectOnce_default(function() {
|
|
console.log.apply(console, __spreadArrays([componentName + " mounted"], rest));
|
|
return function() {
|
|
return console.log(componentName + " unmounted");
|
|
};
|
|
});
|
|
useUpdateEffect_default(function() {
|
|
console.log.apply(console, __spreadArrays([componentName + " updated"], rest));
|
|
});
|
|
};
|
|
var useLogger_default = useLogger;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useLongPress.js
|
|
var import_react53 = __toESM(require_react());
|
|
var isTouchEvent = function(ev) {
|
|
return "touches" in ev;
|
|
};
|
|
var preventDefault2 = function(ev) {
|
|
if (!isTouchEvent(ev))
|
|
return;
|
|
if (ev.touches.length < 2 && ev.preventDefault) {
|
|
ev.preventDefault();
|
|
}
|
|
};
|
|
var useLongPress = function(callback, _a) {
|
|
var _b = _a === void 0 ? {} : _a, _c = _b.isPreventDefault, isPreventDefault = _c === void 0 ? true : _c, _d = _b.delay, delay = _d === void 0 ? 300 : _d;
|
|
var timeout = (0, import_react53.useRef)();
|
|
var target = (0, import_react53.useRef)();
|
|
var start = (0, import_react53.useCallback)(function(event) {
|
|
if (isPreventDefault && event.target) {
|
|
on(event.target, "touchend", preventDefault2, { passive: false });
|
|
target.current = event.target;
|
|
}
|
|
timeout.current = setTimeout(function() {
|
|
return callback(event);
|
|
}, delay);
|
|
}, [callback, delay, isPreventDefault]);
|
|
var clear = (0, import_react53.useCallback)(function() {
|
|
timeout.current && clearTimeout(timeout.current);
|
|
if (isPreventDefault && target.current) {
|
|
off(target.current, "touchend", preventDefault2);
|
|
}
|
|
}, [isPreventDefault]);
|
|
return {
|
|
onMouseDown: function(e2) {
|
|
return start(e2);
|
|
},
|
|
onTouchStart: function(e2) {
|
|
return start(e2);
|
|
},
|
|
onMouseUp: clear,
|
|
onMouseLeave: clear,
|
|
onTouchEnd: clear
|
|
};
|
|
};
|
|
var useLongPress_default = useLongPress;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMap.js
|
|
init_tslib_es6();
|
|
var import_react54 = __toESM(require_react());
|
|
var useMap = function(initialMap) {
|
|
if (initialMap === void 0) {
|
|
initialMap = {};
|
|
}
|
|
var _a = (0, import_react54.useState)(initialMap), map = _a[0], set = _a[1];
|
|
var stableActions = (0, import_react54.useMemo)(function() {
|
|
return {
|
|
set: function(key, entry) {
|
|
set(function(prevMap) {
|
|
var _a2;
|
|
return __assign(__assign({}, prevMap), (_a2 = {}, _a2[key] = entry, _a2));
|
|
});
|
|
},
|
|
setAll: function(newMap) {
|
|
set(newMap);
|
|
},
|
|
remove: function(key) {
|
|
set(function(prevMap) {
|
|
var _a2 = prevMap, _b = key, omit = _a2[_b], rest = __rest(_a2, [typeof _b === "symbol" ? _b : _b + ""]);
|
|
return rest;
|
|
});
|
|
},
|
|
reset: function() {
|
|
return set(initialMap);
|
|
}
|
|
};
|
|
}, [set]);
|
|
var utils = __assign({ get: (0, import_react54.useCallback)(function(key) {
|
|
return map[key];
|
|
}, [map]) }, stableActions);
|
|
return [map, utils];
|
|
};
|
|
var useMap_default = useMap;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMedia.js
|
|
var import_react55 = __toESM(require_react());
|
|
var getInitialState = function(query, defaultState4) {
|
|
if (defaultState4 !== void 0) {
|
|
return defaultState4;
|
|
}
|
|
if (isBrowser) {
|
|
return window.matchMedia(query).matches;
|
|
}
|
|
if (true) {
|
|
console.warn("`useMedia` When server side rendering, defaultState should be defined to prevent a hydration mismatches.");
|
|
}
|
|
return false;
|
|
};
|
|
var useMedia = function(query, defaultState4) {
|
|
var _a = (0, import_react55.useState)(getInitialState(query, defaultState4)), state = _a[0], setState = _a[1];
|
|
(0, import_react55.useEffect)(function() {
|
|
var mounted = true;
|
|
var mql = window.matchMedia(query);
|
|
var onChange = function() {
|
|
if (!mounted) {
|
|
return;
|
|
}
|
|
setState(!!mql.matches);
|
|
};
|
|
mql.addEventListener("change", onChange);
|
|
setState(mql.matches);
|
|
return function() {
|
|
mounted = false;
|
|
mql.removeEventListener("change", onChange);
|
|
};
|
|
}, [query]);
|
|
return state;
|
|
};
|
|
var useMedia_default = useMedia;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMediaDevices.js
|
|
var import_react56 = __toESM(require_react());
|
|
var useMediaDevices = function() {
|
|
var _a = (0, import_react56.useState)({}), state = _a[0], setState = _a[1];
|
|
(0, import_react56.useEffect)(function() {
|
|
var mounted = true;
|
|
var onChange = function() {
|
|
navigator.mediaDevices.enumerateDevices().then(function(devices) {
|
|
if (mounted) {
|
|
setState({
|
|
devices: devices.map(function(_a2) {
|
|
var deviceId = _a2.deviceId, groupId = _a2.groupId, kind = _a2.kind, label = _a2.label;
|
|
return {
|
|
deviceId,
|
|
groupId,
|
|
kind,
|
|
label
|
|
};
|
|
})
|
|
});
|
|
}
|
|
}).catch(noop);
|
|
};
|
|
on(navigator.mediaDevices, "devicechange", onChange);
|
|
onChange();
|
|
return function() {
|
|
mounted = false;
|
|
off(navigator.mediaDevices, "devicechange", onChange);
|
|
};
|
|
}, []);
|
|
return state;
|
|
};
|
|
var useMediaDevicesMock = function() {
|
|
return {};
|
|
};
|
|
var useMediaDevices_default = isNavigator && !!navigator.mediaDevices ? useMediaDevices : useMediaDevicesMock;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMediatedState.js
|
|
var import_react57 = __toESM(require_react());
|
|
function useMediatedState(mediator, initialState) {
|
|
var mediatorFn = (0, import_react57.useRef)(mediator);
|
|
var _a = (0, import_react57.useState)(initialState), state = _a[0], setMediatedState = _a[1];
|
|
var setState = (0, import_react57.useCallback)(function(newState) {
|
|
if (mediatorFn.current.length === 2) {
|
|
mediatorFn.current(newState, setMediatedState);
|
|
} else {
|
|
setMediatedState(mediatorFn.current(newState));
|
|
}
|
|
}, [state]);
|
|
return [state, setState];
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMethods.js
|
|
var import_react58 = __toESM(require_react());
|
|
var useMethods = function(createMethods, initialState) {
|
|
var reducer = (0, import_react58.useMemo)(function() {
|
|
return function(reducerState, action) {
|
|
var _a2;
|
|
return (_a2 = createMethods(reducerState))[action.type].apply(_a2, action.payload);
|
|
};
|
|
}, [createMethods]);
|
|
var _a = (0, import_react58.useReducer)(reducer, initialState), state = _a[0], dispatch = _a[1];
|
|
var wrappedMethods = (0, import_react58.useMemo)(function() {
|
|
var actionTypes = Object.keys(createMethods(initialState));
|
|
return actionTypes.reduce(function(acc, type) {
|
|
acc[type] = function() {
|
|
var payload = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
payload[_i] = arguments[_i];
|
|
}
|
|
return dispatch({ type, payload });
|
|
};
|
|
return acc;
|
|
}, {});
|
|
}, [createMethods, initialState]);
|
|
return [state, wrappedMethods];
|
|
};
|
|
var useMethods_default = useMethods;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMotion.js
|
|
var import_react59 = __toESM(require_react());
|
|
var defaultState = {
|
|
acceleration: {
|
|
x: null,
|
|
y: null,
|
|
z: null
|
|
},
|
|
accelerationIncludingGravity: {
|
|
x: null,
|
|
y: null,
|
|
z: null
|
|
},
|
|
rotationRate: {
|
|
alpha: null,
|
|
beta: null,
|
|
gamma: null
|
|
},
|
|
interval: 16
|
|
};
|
|
var useMotion = function(initialState) {
|
|
if (initialState === void 0) {
|
|
initialState = defaultState;
|
|
}
|
|
var _a = (0, import_react59.useState)(initialState), state = _a[0], setState = _a[1];
|
|
(0, import_react59.useEffect)(function() {
|
|
var handler = function(event) {
|
|
var acceleration = event.acceleration, accelerationIncludingGravity = event.accelerationIncludingGravity, rotationRate = event.rotationRate, interval = event.interval;
|
|
setState({
|
|
acceleration: {
|
|
x: acceleration.x,
|
|
y: acceleration.y,
|
|
z: acceleration.z
|
|
},
|
|
accelerationIncludingGravity: {
|
|
x: accelerationIncludingGravity.x,
|
|
y: accelerationIncludingGravity.y,
|
|
z: accelerationIncludingGravity.z
|
|
},
|
|
rotationRate: {
|
|
alpha: rotationRate.alpha,
|
|
beta: rotationRate.beta,
|
|
gamma: rotationRate.gamma
|
|
},
|
|
interval
|
|
});
|
|
};
|
|
on(window, "devicemotion", handler);
|
|
return function() {
|
|
off(window, "devicemotion", handler);
|
|
};
|
|
}, []);
|
|
return state;
|
|
};
|
|
var useMotion_default = useMotion;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMount.js
|
|
var useMount = function(fn) {
|
|
useEffectOnce_default(function() {
|
|
fn();
|
|
});
|
|
};
|
|
var useMount_default = useMount;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMouse.js
|
|
var import_react62 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useRafState.js
|
|
var import_react61 = __toESM(require_react());
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useUnmount.js
|
|
var import_react60 = __toESM(require_react());
|
|
var useUnmount = function(fn) {
|
|
var fnRef = (0, import_react60.useRef)(fn);
|
|
fnRef.current = fn;
|
|
useEffectOnce_default(function() {
|
|
return function() {
|
|
return fnRef.current();
|
|
};
|
|
});
|
|
};
|
|
var useUnmount_default = useUnmount;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useRafState.js
|
|
var useRafState = function(initialState) {
|
|
var frame = (0, import_react61.useRef)(0);
|
|
var _a = (0, import_react61.useState)(initialState), state = _a[0], setState = _a[1];
|
|
var setRafState = (0, import_react61.useCallback)(function(value) {
|
|
cancelAnimationFrame(frame.current);
|
|
frame.current = requestAnimationFrame(function() {
|
|
setState(value);
|
|
});
|
|
}, []);
|
|
useUnmount_default(function() {
|
|
cancelAnimationFrame(frame.current);
|
|
});
|
|
return [state, setRafState];
|
|
};
|
|
var useRafState_default = useRafState;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMouse.js
|
|
var useMouse = function(ref) {
|
|
if (true) {
|
|
if (typeof ref !== "object" || typeof ref.current === "undefined") {
|
|
console.error("useMouse expects a single ref argument.");
|
|
}
|
|
}
|
|
var _a = useRafState_default({
|
|
docX: 0,
|
|
docY: 0,
|
|
posX: 0,
|
|
posY: 0,
|
|
elX: 0,
|
|
elY: 0,
|
|
elH: 0,
|
|
elW: 0
|
|
}), state = _a[0], setState = _a[1];
|
|
(0, import_react62.useEffect)(function() {
|
|
var moveHandler = function(event) {
|
|
if (ref && ref.current) {
|
|
var _a2 = ref.current.getBoundingClientRect(), left = _a2.left, top_1 = _a2.top, elW = _a2.width, elH = _a2.height;
|
|
var posX = left + window.pageXOffset;
|
|
var posY = top_1 + window.pageYOffset;
|
|
var elX = event.pageX - posX;
|
|
var elY = event.pageY - posY;
|
|
setState({
|
|
docX: event.pageX,
|
|
docY: event.pageY,
|
|
posX,
|
|
posY,
|
|
elX,
|
|
elY,
|
|
elH,
|
|
elW
|
|
});
|
|
}
|
|
};
|
|
on(document, "mousemove", moveHandler);
|
|
return function() {
|
|
off(document, "mousemove", moveHandler);
|
|
};
|
|
}, [ref]);
|
|
return state;
|
|
};
|
|
var useMouse_default = useMouse;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMouseHovered.js
|
|
var nullRef = { current: null };
|
|
var useMouseHovered = function(ref, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
var whenHovered = !!options.whenHovered;
|
|
var bound = !!options.bound;
|
|
var isHovered = useHoverDirty_default(ref, whenHovered);
|
|
var state = useMouse_default(whenHovered && !isHovered ? nullRef : ref);
|
|
if (bound) {
|
|
state.elX = Math.max(0, Math.min(state.elX, state.elW));
|
|
state.elY = Math.max(0, Math.min(state.elY, state.elH));
|
|
}
|
|
return state;
|
|
};
|
|
var useMouseHovered_default = useMouseHovered;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMouseWheel.js
|
|
var import_react63 = __toESM(require_react());
|
|
var useMouseWheel_default = function() {
|
|
var _a = (0, import_react63.useState)(0), mouseWheelScrolled = _a[0], setMouseWheelScrolled = _a[1];
|
|
(0, import_react63.useEffect)(function() {
|
|
var updateScroll = function(e2) {
|
|
setMouseWheelScrolled(e2.deltaY + mouseWheelScrolled);
|
|
};
|
|
on(window, "wheel", updateScroll, false);
|
|
return function() {
|
|
return off(window, "wheel", updateScroll);
|
|
};
|
|
});
|
|
return mouseWheelScrolled;
|
|
};
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useNetworkState.js
|
|
var import_react64 = __toESM(require_react());
|
|
var nav2 = isNavigator ? navigator : void 0;
|
|
var conn = nav2 && (nav2.connection || nav2.mozConnection || nav2.webkitConnection);
|
|
function getConnectionState(previousState) {
|
|
var online = nav2 === null || nav2 === void 0 ? void 0 : nav2.onLine;
|
|
var previousOnline = previousState === null || previousState === void 0 ? void 0 : previousState.online;
|
|
return {
|
|
online,
|
|
previous: previousOnline,
|
|
since: online !== previousOnline ? /* @__PURE__ */ new Date() : previousState === null || previousState === void 0 ? void 0 : previousState.since,
|
|
downlink: conn === null || conn === void 0 ? void 0 : conn.downlink,
|
|
downlinkMax: conn === null || conn === void 0 ? void 0 : conn.downlinkMax,
|
|
effectiveType: conn === null || conn === void 0 ? void 0 : conn.effectiveType,
|
|
rtt: conn === null || conn === void 0 ? void 0 : conn.rtt,
|
|
saveData: conn === null || conn === void 0 ? void 0 : conn.saveData,
|
|
type: conn === null || conn === void 0 ? void 0 : conn.type
|
|
};
|
|
}
|
|
function useNetworkState(initialState) {
|
|
var _a = (0, import_react64.useState)(initialState !== null && initialState !== void 0 ? initialState : getConnectionState), state = _a[0], setState = _a[1];
|
|
(0, import_react64.useEffect)(function() {
|
|
var handleStateChange = function() {
|
|
setState(getConnectionState);
|
|
};
|
|
on(window, "online", handleStateChange, { passive: true });
|
|
on(window, "offline", handleStateChange, { passive: true });
|
|
if (conn) {
|
|
on(conn, "change", handleStateChange, { passive: true });
|
|
}
|
|
return function() {
|
|
off(window, "online", handleStateChange);
|
|
off(window, "offline", handleStateChange);
|
|
if (conn) {
|
|
off(conn, "change", handleStateChange);
|
|
}
|
|
};
|
|
}, []);
|
|
return state;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useNumber.js
|
|
var useNumber_default = useCounter;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useObservable.js
|
|
var import_react65 = __toESM(require_react());
|
|
function useObservable(observable$, initialValue) {
|
|
var _a = (0, import_react65.useState)(initialValue), value = _a[0], update = _a[1];
|
|
useIsomorphicLayoutEffect_default(function() {
|
|
var s = observable$.subscribe(update);
|
|
return function() {
|
|
return s.unsubscribe();
|
|
};
|
|
}, [observable$]);
|
|
return value;
|
|
}
|
|
var useObservable_default = useObservable;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useOrientation.js
|
|
var import_react66 = __toESM(require_react());
|
|
var defaultState2 = {
|
|
angle: 0,
|
|
type: "landscape-primary"
|
|
};
|
|
var useOrientation = function(initialState) {
|
|
if (initialState === void 0) {
|
|
initialState = defaultState2;
|
|
}
|
|
var _a = (0, import_react66.useState)(initialState), state = _a[0], setState = _a[1];
|
|
(0, import_react66.useEffect)(function() {
|
|
var screen = window.screen;
|
|
var mounted = true;
|
|
var onChange = function() {
|
|
if (mounted) {
|
|
var orientation_1 = screen.orientation;
|
|
if (orientation_1) {
|
|
var angle = orientation_1.angle, type = orientation_1.type;
|
|
setState({ angle, type });
|
|
} else if (window.orientation !== void 0) {
|
|
setState({
|
|
angle: typeof window.orientation === "number" ? window.orientation : 0,
|
|
type: ""
|
|
});
|
|
} else {
|
|
setState(initialState);
|
|
}
|
|
}
|
|
};
|
|
on(window, "orientationchange", onChange);
|
|
onChange();
|
|
return function() {
|
|
mounted = false;
|
|
off(window, "orientationchange", onChange);
|
|
};
|
|
}, []);
|
|
return state;
|
|
};
|
|
var useOrientation_default = useOrientation;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/usePageLeave.js
|
|
var import_react67 = __toESM(require_react());
|
|
var usePageLeave = function(onPageLeave, args) {
|
|
if (args === void 0) {
|
|
args = [];
|
|
}
|
|
(0, import_react67.useEffect)(function() {
|
|
if (!onPageLeave) {
|
|
return;
|
|
}
|
|
var handler = function(event) {
|
|
event = event ? event : window.event;
|
|
var from = event.relatedTarget || event.toElement;
|
|
if (!from || from.nodeName === "HTML") {
|
|
onPageLeave();
|
|
}
|
|
};
|
|
on(document, "mouseout", handler);
|
|
return function() {
|
|
off(document, "mouseout", handler);
|
|
};
|
|
}, args);
|
|
};
|
|
var usePageLeave_default = usePageLeave;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/usePermission.js
|
|
var import_react68 = __toESM(require_react());
|
|
var usePermission = function(permissionDesc) {
|
|
var _a = (0, import_react68.useState)(""), state = _a[0], setState = _a[1];
|
|
(0, import_react68.useEffect)(function() {
|
|
var mounted = true;
|
|
var permissionStatus = null;
|
|
var onChange = function() {
|
|
if (!mounted) {
|
|
return;
|
|
}
|
|
setState(function() {
|
|
var _a2;
|
|
return (_a2 = permissionStatus === null || permissionStatus === void 0 ? void 0 : permissionStatus.state) !== null && _a2 !== void 0 ? _a2 : "";
|
|
});
|
|
};
|
|
navigator.permissions.query(permissionDesc).then(function(status) {
|
|
permissionStatus = status;
|
|
on(permissionStatus, "change", onChange);
|
|
onChange();
|
|
}).catch(noop);
|
|
return function() {
|
|
permissionStatus && off(permissionStatus, "change", onChange);
|
|
mounted = false;
|
|
permissionStatus = null;
|
|
};
|
|
}, [permissionDesc]);
|
|
return state;
|
|
};
|
|
var usePermission_default = usePermission;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/usePrevious.js
|
|
var import_react69 = __toESM(require_react());
|
|
function usePrevious(state) {
|
|
var ref = (0, import_react69.useRef)();
|
|
(0, import_react69.useEffect)(function() {
|
|
ref.current = state;
|
|
});
|
|
return ref.current;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/usePreviousDistinct.js
|
|
var import_react70 = __toESM(require_react());
|
|
var strictEquals = function(prev, next) {
|
|
return prev === next;
|
|
};
|
|
function usePreviousDistinct(value, compare) {
|
|
if (compare === void 0) {
|
|
compare = strictEquals;
|
|
}
|
|
var prevRef = (0, import_react70.useRef)();
|
|
var curRef = (0, import_react70.useRef)(value);
|
|
var isFirstMount = useFirstMountState();
|
|
if (!isFirstMount && !compare(curRef.current, value)) {
|
|
prevRef.current = curRef.current;
|
|
curRef.current = value;
|
|
}
|
|
return prevRef.current;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/usePromise.js
|
|
var import_react71 = __toESM(require_react());
|
|
var usePromise = function() {
|
|
var isMounted = useMountedState();
|
|
return (0, import_react71.useCallback)(function(promise) {
|
|
return new Promise(function(resolve, reject) {
|
|
var onValue = function(value) {
|
|
isMounted() && resolve(value);
|
|
};
|
|
var onError = function(error) {
|
|
isMounted() && reject(error);
|
|
};
|
|
promise.then(onValue, onError);
|
|
});
|
|
}, []);
|
|
};
|
|
var usePromise_default = usePromise;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useQueue.js
|
|
init_tslib_es6();
|
|
var import_react72 = __toESM(require_react());
|
|
var useQueue = function(initialValue) {
|
|
if (initialValue === void 0) {
|
|
initialValue = [];
|
|
}
|
|
var _a = (0, import_react72.useState)(initialValue), state = _a[0], set = _a[1];
|
|
return {
|
|
add: function(value) {
|
|
set(function(queue) {
|
|
return __spreadArrays(queue, [value]);
|
|
});
|
|
},
|
|
remove: function() {
|
|
var result;
|
|
set(function(_a2) {
|
|
var first = _a2[0], rest = _a2.slice(1);
|
|
result = first;
|
|
return rest;
|
|
});
|
|
return result;
|
|
},
|
|
get first() {
|
|
return state[0];
|
|
},
|
|
get last() {
|
|
return state[state.length - 1];
|
|
},
|
|
get size() {
|
|
return state.length;
|
|
}
|
|
};
|
|
};
|
|
var useQueue_default = useQueue;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useRaf.js
|
|
var import_react73 = __toESM(require_react());
|
|
var useRaf = function(ms, delay) {
|
|
if (ms === void 0) {
|
|
ms = 1e12;
|
|
}
|
|
if (delay === void 0) {
|
|
delay = 0;
|
|
}
|
|
var _a = (0, import_react73.useState)(0), elapsed = _a[0], set = _a[1];
|
|
useIsomorphicLayoutEffect_default(function() {
|
|
var raf;
|
|
var timerStop;
|
|
var start;
|
|
var onFrame = function() {
|
|
var time = Math.min(1, (Date.now() - start) / ms);
|
|
set(time);
|
|
loop();
|
|
};
|
|
var loop = function() {
|
|
raf = requestAnimationFrame(onFrame);
|
|
};
|
|
var onStart = function() {
|
|
timerStop = setTimeout(function() {
|
|
cancelAnimationFrame(raf);
|
|
set(1);
|
|
}, ms);
|
|
start = Date.now();
|
|
loop();
|
|
};
|
|
var timerDelay = setTimeout(onStart, delay);
|
|
return function() {
|
|
clearTimeout(timerStop);
|
|
clearTimeout(timerDelay);
|
|
cancelAnimationFrame(raf);
|
|
};
|
|
}, [ms, delay]);
|
|
return elapsed;
|
|
};
|
|
var useRaf_default = useRaf;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useRafLoop.js
|
|
var import_react74 = __toESM(require_react());
|
|
function useRafLoop(callback, initiallyActive) {
|
|
if (initiallyActive === void 0) {
|
|
initiallyActive = true;
|
|
}
|
|
var raf = (0, import_react74.useRef)(null);
|
|
var rafActivity = (0, import_react74.useRef)(false);
|
|
var rafCallback = (0, import_react74.useRef)(callback);
|
|
rafCallback.current = callback;
|
|
var step = (0, import_react74.useCallback)(function(time) {
|
|
if (rafActivity.current) {
|
|
rafCallback.current(time);
|
|
raf.current = requestAnimationFrame(step);
|
|
}
|
|
}, []);
|
|
var result = (0, import_react74.useMemo)(function() {
|
|
return [
|
|
function() {
|
|
if (rafActivity.current) {
|
|
rafActivity.current = false;
|
|
raf.current && cancelAnimationFrame(raf.current);
|
|
}
|
|
},
|
|
function() {
|
|
if (!rafActivity.current) {
|
|
rafActivity.current = true;
|
|
raf.current = requestAnimationFrame(step);
|
|
}
|
|
},
|
|
function() {
|
|
return rafActivity.current;
|
|
}
|
|
];
|
|
}, []);
|
|
(0, import_react74.useEffect)(function() {
|
|
if (initiallyActive) {
|
|
result[1]();
|
|
}
|
|
return result[0];
|
|
}, []);
|
|
return result;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useSearchParam.js
|
|
var import_react75 = __toESM(require_react());
|
|
var getValue = function(search, param) {
|
|
return new URLSearchParams(search).get(param);
|
|
};
|
|
var useSearchParam = function(param) {
|
|
var location = window.location;
|
|
var _a = (0, import_react75.useState)(function() {
|
|
return getValue(location.search, param);
|
|
}), value = _a[0], setValue = _a[1];
|
|
(0, import_react75.useEffect)(function() {
|
|
var onChange = function() {
|
|
setValue(getValue(location.search, param));
|
|
};
|
|
on(window, "popstate", onChange);
|
|
on(window, "pushstate", onChange);
|
|
on(window, "replacestate", onChange);
|
|
return function() {
|
|
off(window, "popstate", onChange);
|
|
off(window, "pushstate", onChange);
|
|
off(window, "replacestate", onChange);
|
|
};
|
|
}, []);
|
|
return value;
|
|
};
|
|
var useSearchParamServer = function() {
|
|
return null;
|
|
};
|
|
var useSearchParam_default = isBrowser ? useSearchParam : useSearchParamServer;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useScratch.js
|
|
init_tslib_es6();
|
|
var import_react76 = __toESM(require_react());
|
|
var import_react_universal_interface = __toESM(require_lib());
|
|
var useScratch = function(params) {
|
|
if (params === void 0) {
|
|
params = {};
|
|
}
|
|
var disabled = params.disabled;
|
|
var paramsRef = useLatest_default(params);
|
|
var _a = (0, import_react76.useState)({ isScratching: false }), state = _a[0], setState = _a[1];
|
|
var refState = (0, import_react76.useRef)(state);
|
|
var refScratching = (0, import_react76.useRef)(false);
|
|
var refAnimationFrame = (0, import_react76.useRef)(null);
|
|
var _b = (0, import_react76.useState)(null), el = _b[0], setEl = _b[1];
|
|
(0, import_react76.useEffect)(function() {
|
|
if (disabled)
|
|
return;
|
|
if (!el)
|
|
return;
|
|
var onMoveEvent = function(docX, docY) {
|
|
cancelAnimationFrame(refAnimationFrame.current);
|
|
refAnimationFrame.current = requestAnimationFrame(function() {
|
|
var _a2 = el.getBoundingClientRect(), left = _a2.left, top = _a2.top;
|
|
var elX = left + window.scrollX;
|
|
var elY = top + window.scrollY;
|
|
var x = docX - elX;
|
|
var y = docY - elY;
|
|
setState(function(oldState) {
|
|
var newState = __assign(__assign({}, oldState), { dx: x - (oldState.x || 0), dy: y - (oldState.y || 0), end: Date.now(), isScratching: true });
|
|
refState.current = newState;
|
|
(paramsRef.current.onScratch || noop)(newState);
|
|
return newState;
|
|
});
|
|
});
|
|
};
|
|
var onMouseMove = function(event) {
|
|
onMoveEvent(event.pageX, event.pageY);
|
|
};
|
|
var onTouchMove = function(event) {
|
|
onMoveEvent(event.changedTouches[0].pageX, event.changedTouches[0].pageY);
|
|
};
|
|
var onMouseUp;
|
|
var onTouchEnd;
|
|
var stopScratching = function() {
|
|
if (!refScratching.current)
|
|
return;
|
|
refScratching.current = false;
|
|
refState.current = __assign(__assign({}, refState.current), { isScratching: false });
|
|
(paramsRef.current.onScratchEnd || noop)(refState.current);
|
|
setState({ isScratching: false });
|
|
off(window, "mousemove", onMouseMove);
|
|
off(window, "touchmove", onTouchMove);
|
|
off(window, "mouseup", onMouseUp);
|
|
off(window, "touchend", onTouchEnd);
|
|
};
|
|
onMouseUp = stopScratching;
|
|
onTouchEnd = stopScratching;
|
|
var startScratching = function(docX, docY) {
|
|
if (!refScratching.current)
|
|
return;
|
|
var _a2 = el.getBoundingClientRect(), left = _a2.left, top = _a2.top;
|
|
var elX = left + window.scrollX;
|
|
var elY = top + window.scrollY;
|
|
var x = docX - elX;
|
|
var y = docY - elY;
|
|
var time = Date.now();
|
|
var newState = {
|
|
isScratching: true,
|
|
start: time,
|
|
end: time,
|
|
docX,
|
|
docY,
|
|
x,
|
|
y,
|
|
dx: 0,
|
|
dy: 0,
|
|
elH: el.offsetHeight,
|
|
elW: el.offsetWidth,
|
|
elX,
|
|
elY
|
|
};
|
|
refState.current = newState;
|
|
(paramsRef.current.onScratchStart || noop)(newState);
|
|
setState(newState);
|
|
on(window, "mousemove", onMouseMove);
|
|
on(window, "touchmove", onTouchMove);
|
|
on(window, "mouseup", onMouseUp);
|
|
on(window, "touchend", onTouchEnd);
|
|
};
|
|
var onMouseDown = function(event) {
|
|
refScratching.current = true;
|
|
startScratching(event.pageX, event.pageY);
|
|
};
|
|
var onTouchStart = function(event) {
|
|
refScratching.current = true;
|
|
startScratching(event.changedTouches[0].pageX, event.changedTouches[0].pageY);
|
|
};
|
|
on(el, "mousedown", onMouseDown);
|
|
on(el, "touchstart", onTouchStart);
|
|
return function() {
|
|
off(el, "mousedown", onMouseDown);
|
|
off(el, "touchstart", onTouchStart);
|
|
off(window, "mousemove", onMouseMove);
|
|
off(window, "touchmove", onTouchMove);
|
|
off(window, "mouseup", onMouseUp);
|
|
off(window, "touchend", onTouchEnd);
|
|
if (refAnimationFrame.current)
|
|
cancelAnimationFrame(refAnimationFrame.current);
|
|
refAnimationFrame.current = null;
|
|
refScratching.current = false;
|
|
refState.current = { isScratching: false };
|
|
setState(refState.current);
|
|
};
|
|
}, [el, disabled, paramsRef]);
|
|
return [setEl, state];
|
|
};
|
|
var useScratch_default = useScratch;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useScroll.js
|
|
var import_react77 = __toESM(require_react());
|
|
var useScroll = function(ref) {
|
|
if (true) {
|
|
if (typeof ref !== "object" || typeof ref.current === "undefined") {
|
|
console.error("`useScroll` expects a single ref argument.");
|
|
}
|
|
}
|
|
var _a = useRafState_default({
|
|
x: 0,
|
|
y: 0
|
|
}), state = _a[0], setState = _a[1];
|
|
(0, import_react77.useEffect)(function() {
|
|
var handler = function() {
|
|
if (ref.current) {
|
|
setState({
|
|
x: ref.current.scrollLeft,
|
|
y: ref.current.scrollTop
|
|
});
|
|
}
|
|
};
|
|
if (ref.current) {
|
|
on(ref.current, "scroll", handler, {
|
|
capture: false,
|
|
passive: true
|
|
});
|
|
}
|
|
return function() {
|
|
if (ref.current) {
|
|
off(ref.current, "scroll", handler);
|
|
}
|
|
};
|
|
}, [ref]);
|
|
return state;
|
|
};
|
|
var useScroll_default = useScroll;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useScrolling.js
|
|
var import_react78 = __toESM(require_react());
|
|
var useScrolling = function(ref) {
|
|
var _a = (0, import_react78.useState)(false), scrolling = _a[0], setScrolling = _a[1];
|
|
(0, import_react78.useEffect)(function() {
|
|
if (ref.current) {
|
|
var scrollingTimeout_1;
|
|
var handleScrollEnd_1 = function() {
|
|
setScrolling(false);
|
|
};
|
|
var handleScroll_1 = function() {
|
|
setScrolling(true);
|
|
clearTimeout(scrollingTimeout_1);
|
|
scrollingTimeout_1 = setTimeout(function() {
|
|
return handleScrollEnd_1();
|
|
}, 150);
|
|
};
|
|
on(ref.current, "scroll", handleScroll_1, false);
|
|
return function() {
|
|
if (ref.current) {
|
|
off(ref.current, "scroll", handleScroll_1, false);
|
|
}
|
|
};
|
|
}
|
|
return function() {
|
|
};
|
|
}, [ref]);
|
|
return scrolling;
|
|
};
|
|
var useScrolling_default = useScrolling;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useSessionStorage.js
|
|
var import_react79 = __toESM(require_react());
|
|
var useSessionStorage = function(key, initialValue, raw) {
|
|
if (!isBrowser) {
|
|
return [initialValue, function() {
|
|
}];
|
|
}
|
|
var _a = (0, import_react79.useState)(function() {
|
|
try {
|
|
var sessionStorageValue = sessionStorage.getItem(key);
|
|
if (typeof sessionStorageValue !== "string") {
|
|
sessionStorage.setItem(key, raw ? String(initialValue) : JSON.stringify(initialValue));
|
|
return initialValue;
|
|
} else {
|
|
return raw ? sessionStorageValue : JSON.parse(sessionStorageValue || "null");
|
|
}
|
|
} catch (_a2) {
|
|
return initialValue;
|
|
}
|
|
}), state = _a[0], setState = _a[1];
|
|
(0, import_react79.useEffect)(function() {
|
|
try {
|
|
var serializedState = raw ? String(state) : JSON.stringify(state);
|
|
sessionStorage.setItem(key, serializedState);
|
|
} catch (_a2) {
|
|
}
|
|
});
|
|
return [state, setState];
|
|
};
|
|
var useSessionStorage_default = useSessionStorage;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useShallowCompareEffect.js
|
|
var import_fast_shallow_equal = __toESM(require_fast_shallow_equal());
|
|
var isPrimitive3 = function(val) {
|
|
return val !== Object(val);
|
|
};
|
|
var shallowEqualDepsList = function(prevDeps, nextDeps) {
|
|
return prevDeps.every(function(dep, index) {
|
|
return (0, import_fast_shallow_equal.equal)(dep, nextDeps[index]);
|
|
});
|
|
};
|
|
var useShallowCompareEffect = function(effect, deps) {
|
|
if (true) {
|
|
if (!(deps instanceof Array) || !deps.length) {
|
|
console.warn("`useShallowCompareEffect` should not be used with no dependencies. Use React.useEffect instead.");
|
|
}
|
|
if (deps.every(isPrimitive3)) {
|
|
console.warn("`useShallowCompareEffect` should not be used with dependencies that are all primitive values. Use React.useEffect instead.");
|
|
}
|
|
}
|
|
useCustomCompareEffect_default(effect, deps, shallowEqualDepsList);
|
|
};
|
|
var useShallowCompareEffect_default = useShallowCompareEffect;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useSize.js
|
|
init_tslib_es6();
|
|
var React3 = __toESM(require_react());
|
|
var useState41 = React3.useState;
|
|
var useEffect45 = React3.useEffect;
|
|
var useRef27 = React3.useRef;
|
|
var DRAF = function(callback) {
|
|
return setTimeout(callback, 35);
|
|
};
|
|
var useSize = function(element, _a) {
|
|
var _b = _a === void 0 ? {} : _a, _c = _b.width, width = _c === void 0 ? Infinity : _c, _d = _b.height, height = _d === void 0 ? Infinity : _d;
|
|
if (!isBrowser) {
|
|
return [
|
|
typeof element === "function" ? element({ width, height }) : element,
|
|
{ width, height }
|
|
];
|
|
}
|
|
var _e = useState41({ width, height }), state = _e[0], setState = _e[1];
|
|
if (typeof element === "function") {
|
|
element = element(state);
|
|
}
|
|
var style = element.props.style || {};
|
|
var ref = useRef27(null);
|
|
var window2 = null;
|
|
var setSize = function() {
|
|
var iframe = ref.current;
|
|
var size = iframe ? {
|
|
width: iframe.offsetWidth,
|
|
height: iframe.offsetHeight
|
|
} : { width, height };
|
|
setState(size);
|
|
};
|
|
var onWindow = function(windowToListenOn) {
|
|
on(windowToListenOn, "resize", setSize);
|
|
DRAF(setSize);
|
|
};
|
|
useEffect45(function() {
|
|
var iframe = ref.current;
|
|
if (!iframe) {
|
|
return;
|
|
}
|
|
if (iframe.contentWindow) {
|
|
window2 = iframe.contentWindow;
|
|
onWindow(window2);
|
|
} else {
|
|
var onLoad_1 = function() {
|
|
on(iframe, "load", onLoad_1);
|
|
window2 = iframe.contentWindow;
|
|
onWindow(window2);
|
|
};
|
|
off(iframe, "load", onLoad_1);
|
|
}
|
|
return function() {
|
|
if (window2 && window2.removeEventListener) {
|
|
off(window2, "resize", setSize);
|
|
}
|
|
};
|
|
}, []);
|
|
style.position = "relative";
|
|
var sized = React3.cloneElement.apply(React3, __spreadArrays([element, { style }], __spreadArrays([
|
|
React3.createElement("iframe", {
|
|
ref,
|
|
style: {
|
|
background: "transparent",
|
|
border: "none",
|
|
height: "100%",
|
|
left: 0,
|
|
position: "absolute",
|
|
top: 0,
|
|
width: "100%",
|
|
zIndex: -1
|
|
}
|
|
})
|
|
], React3.Children.toArray(element.props.children))));
|
|
return [sized, state];
|
|
};
|
|
var useSize_default = useSize;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useSlider.js
|
|
var import_react80 = __toESM(require_react());
|
|
var useSlider = function(ref, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
var isMounted = useMountedState();
|
|
var isSliding = (0, import_react80.useRef)(false);
|
|
var valueRef = (0, import_react80.useRef)(0);
|
|
var frame = (0, import_react80.useRef)(0);
|
|
var _a = useSetState_default({
|
|
isSliding: false,
|
|
value: 0
|
|
}), state = _a[0], setState = _a[1];
|
|
valueRef.current = state.value;
|
|
(0, import_react80.useEffect)(function() {
|
|
if (isBrowser) {
|
|
var styles = options.styles === void 0 ? true : options.styles;
|
|
var reverse_1 = options.reverse === void 0 ? false : options.reverse;
|
|
if (ref.current && styles) {
|
|
ref.current.style.userSelect = "none";
|
|
}
|
|
var startScrubbing_1 = function() {
|
|
if (!isSliding.current && isMounted()) {
|
|
(options.onScrubStart || noop)();
|
|
isSliding.current = true;
|
|
setState({ isSliding: true });
|
|
bindEvents_1();
|
|
}
|
|
};
|
|
var stopScrubbing_1 = function() {
|
|
if (isSliding.current && isMounted()) {
|
|
(options.onScrubStop || noop)(valueRef.current);
|
|
isSliding.current = false;
|
|
setState({ isSliding: false });
|
|
unbindEvents_1();
|
|
}
|
|
};
|
|
var onMouseDown_1 = function(event) {
|
|
startScrubbing_1();
|
|
onMouseMove_1(event);
|
|
};
|
|
var onMouseMove_1 = options.vertical ? function(event) {
|
|
return onScrub_1(event.clientY);
|
|
} : function(event) {
|
|
return onScrub_1(event.clientX);
|
|
};
|
|
var onTouchStart_1 = function(event) {
|
|
startScrubbing_1();
|
|
onTouchMove_1(event);
|
|
};
|
|
var onTouchMove_1 = options.vertical ? function(event) {
|
|
return onScrub_1(event.changedTouches[0].clientY);
|
|
} : function(event) {
|
|
return onScrub_1(event.changedTouches[0].clientX);
|
|
};
|
|
var bindEvents_1 = function() {
|
|
on(document, "mousemove", onMouseMove_1);
|
|
on(document, "mouseup", stopScrubbing_1);
|
|
on(document, "touchmove", onTouchMove_1);
|
|
on(document, "touchend", stopScrubbing_1);
|
|
};
|
|
var unbindEvents_1 = function() {
|
|
off(document, "mousemove", onMouseMove_1);
|
|
off(document, "mouseup", stopScrubbing_1);
|
|
off(document, "touchmove", onTouchMove_1);
|
|
off(document, "touchend", stopScrubbing_1);
|
|
};
|
|
var onScrub_1 = function(clientXY) {
|
|
cancelAnimationFrame(frame.current);
|
|
frame.current = requestAnimationFrame(function() {
|
|
if (isMounted() && ref.current) {
|
|
var rect = ref.current.getBoundingClientRect();
|
|
var pos = options.vertical ? rect.top : rect.left;
|
|
var length_1 = options.vertical ? rect.height : rect.width;
|
|
if (!length_1) {
|
|
return;
|
|
}
|
|
var value = (clientXY - pos) / length_1;
|
|
if (value > 1) {
|
|
value = 1;
|
|
} else if (value < 0) {
|
|
value = 0;
|
|
}
|
|
if (reverse_1) {
|
|
value = 1 - value;
|
|
}
|
|
setState({
|
|
value
|
|
});
|
|
(options.onScrub || noop)(value);
|
|
}
|
|
});
|
|
};
|
|
on(ref.current, "mousedown", onMouseDown_1);
|
|
on(ref.current, "touchstart", onTouchStart_1);
|
|
return function() {
|
|
off(ref.current, "mousedown", onMouseDown_1);
|
|
off(ref.current, "touchstart", onTouchStart_1);
|
|
};
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}, [ref, options.vertical]);
|
|
return state;
|
|
};
|
|
var useSlider_default = useSlider;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useSpeech.js
|
|
init_tslib_es6();
|
|
var import_react81 = __toESM(require_react());
|
|
var Status;
|
|
(function(Status2) {
|
|
Status2[Status2["init"] = 0] = "init";
|
|
Status2[Status2["play"] = 1] = "play";
|
|
Status2[Status2["pause"] = 2] = "pause";
|
|
Status2[Status2["end"] = 3] = "end";
|
|
})(Status || (Status = {}));
|
|
var useSpeech = function(text, options) {
|
|
var mounted = (0, import_react81.useRef)(false);
|
|
var _a = (0, import_react81.useState)(function() {
|
|
var _a2 = options.voice || {}, _b = _a2.lang, lang = _b === void 0 ? "default" : _b, _c = _a2.name, name = _c === void 0 ? "" : _c;
|
|
return {
|
|
isPlaying: false,
|
|
status: Status[Status.init],
|
|
lang: options.lang || "default",
|
|
voiceInfo: { lang, name },
|
|
rate: options.rate || 1,
|
|
pitch: options.pitch || 1,
|
|
volume: options.volume || 1
|
|
};
|
|
}), state = _a[0], setState = _a[1];
|
|
var handlePlay = (0, import_react81.useCallback)(function() {
|
|
if (!mounted.current) {
|
|
return;
|
|
}
|
|
setState(function(preState) {
|
|
return __assign(__assign({}, preState), { isPlaying: true, status: Status[Status.play] });
|
|
});
|
|
}, []);
|
|
var handlePause = (0, import_react81.useCallback)(function() {
|
|
if (!mounted.current) {
|
|
return;
|
|
}
|
|
setState(function(preState) {
|
|
return __assign(__assign({}, preState), { isPlaying: false, status: Status[Status.pause] });
|
|
});
|
|
}, []);
|
|
var handleEnd = (0, import_react81.useCallback)(function() {
|
|
if (!mounted.current) {
|
|
return;
|
|
}
|
|
setState(function(preState) {
|
|
return __assign(__assign({}, preState), { isPlaying: false, status: Status[Status.end] });
|
|
});
|
|
}, []);
|
|
(0, import_react81.useEffect)(function() {
|
|
mounted.current = true;
|
|
var utterance = new SpeechSynthesisUtterance(text);
|
|
options.lang && (utterance.lang = options.lang);
|
|
options.voice && (utterance.voice = options.voice);
|
|
utterance.rate = options.rate || 1;
|
|
utterance.pitch = options.pitch || 1;
|
|
utterance.volume = options.volume || 1;
|
|
utterance.onstart = handlePlay;
|
|
utterance.onpause = handlePause;
|
|
utterance.onresume = handlePlay;
|
|
utterance.onend = handleEnd;
|
|
window.speechSynthesis.speak(utterance);
|
|
return function() {
|
|
mounted.current = false;
|
|
};
|
|
}, []);
|
|
return state;
|
|
};
|
|
var useSpeech_default = useSpeech;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useStartTyping.js
|
|
var isFocusedElementEditable = function() {
|
|
var activeElement = document.activeElement, body = document.body;
|
|
if (!activeElement) {
|
|
return false;
|
|
}
|
|
if (activeElement === body) {
|
|
return false;
|
|
}
|
|
switch (activeElement.tagName) {
|
|
case "INPUT":
|
|
case "TEXTAREA":
|
|
return true;
|
|
}
|
|
return activeElement.hasAttribute("contenteditable");
|
|
};
|
|
var isTypedCharGood = function(_a) {
|
|
var keyCode = _a.keyCode, metaKey = _a.metaKey, ctrlKey = _a.ctrlKey, altKey = _a.altKey;
|
|
if (metaKey || ctrlKey || altKey) {
|
|
return false;
|
|
}
|
|
if (keyCode >= 48 && keyCode <= 57) {
|
|
return true;
|
|
}
|
|
if (keyCode >= 65 && keyCode <= 90) {
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
var useStartTyping = function(onStartTyping) {
|
|
useIsomorphicLayoutEffect_default(function() {
|
|
var keydown = function(event) {
|
|
!isFocusedElementEditable() && isTypedCharGood(event) && onStartTyping(event);
|
|
};
|
|
on(document, "keydown", keydown);
|
|
return function() {
|
|
off(document, "keydown", keydown);
|
|
};
|
|
}, []);
|
|
};
|
|
var useStartTyping_default = useStartTyping;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useStateWithHistory.js
|
|
var import_react82 = __toESM(require_react());
|
|
function useStateWithHistory(initialState, capacity, initialHistory) {
|
|
if (capacity === void 0) {
|
|
capacity = 10;
|
|
}
|
|
if (capacity < 1) {
|
|
throw new Error("Capacity has to be greater than 1, got '" + capacity + "'");
|
|
}
|
|
var isFirstMount = useFirstMountState();
|
|
var _a = (0, import_react82.useState)(initialState), state = _a[0], innerSetState = _a[1];
|
|
var history = (0, import_react82.useRef)(initialHistory !== null && initialHistory !== void 0 ? initialHistory : []);
|
|
var historyPosition = (0, import_react82.useRef)(0);
|
|
if (isFirstMount) {
|
|
if (history.current.length) {
|
|
if (history.current[history.current.length - 1] !== initialState) {
|
|
history.current.push(initialState);
|
|
}
|
|
if (history.current.length > capacity) {
|
|
history.current = history.current.slice(history.current.length - capacity);
|
|
}
|
|
} else {
|
|
history.current.push(initialState);
|
|
}
|
|
historyPosition.current = history.current.length && history.current.length - 1;
|
|
}
|
|
var setState = (0, import_react82.useCallback)(function(newState) {
|
|
innerSetState(function(currentState) {
|
|
newState = resolveHookState(newState, currentState);
|
|
if (newState !== currentState) {
|
|
if (historyPosition.current < history.current.length - 1) {
|
|
history.current = history.current.slice(0, historyPosition.current + 1);
|
|
}
|
|
historyPosition.current = history.current.push(newState) - 1;
|
|
if (history.current.length > capacity) {
|
|
history.current = history.current.slice(history.current.length - capacity);
|
|
}
|
|
}
|
|
return newState;
|
|
});
|
|
}, [state, capacity]);
|
|
var historyState = (0, import_react82.useMemo)(function() {
|
|
return {
|
|
history: history.current,
|
|
position: historyPosition.current,
|
|
capacity,
|
|
back: function(amount) {
|
|
if (amount === void 0) {
|
|
amount = 1;
|
|
}
|
|
if (!historyPosition.current) {
|
|
return;
|
|
}
|
|
innerSetState(function() {
|
|
historyPosition.current -= Math.min(amount, historyPosition.current);
|
|
return history.current[historyPosition.current];
|
|
});
|
|
},
|
|
forward: function(amount) {
|
|
if (amount === void 0) {
|
|
amount = 1;
|
|
}
|
|
if (historyPosition.current === history.current.length - 1) {
|
|
return;
|
|
}
|
|
innerSetState(function() {
|
|
historyPosition.current = Math.min(historyPosition.current + amount, history.current.length - 1);
|
|
return history.current[historyPosition.current];
|
|
});
|
|
},
|
|
go: function(position) {
|
|
if (position === historyPosition.current) {
|
|
return;
|
|
}
|
|
innerSetState(function() {
|
|
historyPosition.current = position < 0 ? Math.max(history.current.length + position, 0) : Math.min(history.current.length - 1, position);
|
|
return history.current[historyPosition.current];
|
|
});
|
|
}
|
|
};
|
|
}, [state]);
|
|
return [state, setState, historyState];
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useStateList.js
|
|
init_tslib_es6();
|
|
var import_react83 = __toESM(require_react());
|
|
function useStateList(stateSet) {
|
|
if (stateSet === void 0) {
|
|
stateSet = [];
|
|
}
|
|
var isMounted = useMountedState();
|
|
var update = useUpdate();
|
|
var index = (0, import_react83.useRef)(0);
|
|
useUpdateEffect_default(function() {
|
|
if (stateSet.length <= index.current) {
|
|
index.current = stateSet.length - 1;
|
|
update();
|
|
}
|
|
}, [stateSet.length]);
|
|
var actions = (0, import_react83.useMemo)(function() {
|
|
return {
|
|
next: function() {
|
|
return actions.setStateAt(index.current + 1);
|
|
},
|
|
prev: function() {
|
|
return actions.setStateAt(index.current - 1);
|
|
},
|
|
setStateAt: function(newIndex) {
|
|
if (!isMounted())
|
|
return;
|
|
if (!stateSet.length)
|
|
return;
|
|
if (newIndex === index.current)
|
|
return;
|
|
index.current = newIndex >= 0 ? newIndex % stateSet.length : stateSet.length + newIndex % stateSet.length;
|
|
update();
|
|
},
|
|
setState: function(state) {
|
|
if (!isMounted())
|
|
return;
|
|
var newIndex = stateSet.length ? stateSet.indexOf(state) : -1;
|
|
if (newIndex === -1) {
|
|
throw new Error("State '" + state + "' is not a valid state (does not exist in state list)");
|
|
}
|
|
index.current = newIndex;
|
|
update();
|
|
}
|
|
};
|
|
}, [stateSet]);
|
|
return __assign({ state: stateSet[index.current], currentIndex: index.current, isFirst: index.current === 0, isLast: index.current === stateSet.length - 1 }, actions);
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useThrottle.js
|
|
var import_react84 = __toESM(require_react());
|
|
var useThrottle = function(value, ms) {
|
|
if (ms === void 0) {
|
|
ms = 200;
|
|
}
|
|
var _a = (0, import_react84.useState)(value), state = _a[0], setState = _a[1];
|
|
var timeout = (0, import_react84.useRef)();
|
|
var nextValue = (0, import_react84.useRef)(null);
|
|
var hasNextValue = (0, import_react84.useRef)(0);
|
|
(0, import_react84.useEffect)(function() {
|
|
if (!timeout.current) {
|
|
setState(value);
|
|
var timeoutCallback_1 = function() {
|
|
if (hasNextValue.current) {
|
|
hasNextValue.current = false;
|
|
setState(nextValue.current);
|
|
timeout.current = setTimeout(timeoutCallback_1, ms);
|
|
} else {
|
|
timeout.current = void 0;
|
|
}
|
|
};
|
|
timeout.current = setTimeout(timeoutCallback_1, ms);
|
|
} else {
|
|
nextValue.current = value;
|
|
hasNextValue.current = true;
|
|
}
|
|
}, [value]);
|
|
useUnmount_default(function() {
|
|
timeout.current && clearTimeout(timeout.current);
|
|
});
|
|
return state;
|
|
};
|
|
var useThrottle_default = useThrottle;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useThrottleFn.js
|
|
var import_react85 = __toESM(require_react());
|
|
var useThrottleFn = function(fn, ms, args) {
|
|
if (ms === void 0) {
|
|
ms = 200;
|
|
}
|
|
var _a = (0, import_react85.useState)(null), state = _a[0], setState = _a[1];
|
|
var timeout = (0, import_react85.useRef)();
|
|
var nextArgs = (0, import_react85.useRef)();
|
|
(0, import_react85.useEffect)(function() {
|
|
if (!timeout.current) {
|
|
setState(fn.apply(void 0, args));
|
|
var timeoutCallback_1 = function() {
|
|
if (nextArgs.current) {
|
|
setState(fn.apply(void 0, nextArgs.current));
|
|
nextArgs.current = void 0;
|
|
timeout.current = setTimeout(timeoutCallback_1, ms);
|
|
} else {
|
|
timeout.current = void 0;
|
|
}
|
|
};
|
|
timeout.current = setTimeout(timeoutCallback_1, ms);
|
|
} else {
|
|
nextArgs.current = args;
|
|
}
|
|
}, args);
|
|
useUnmount_default(function() {
|
|
timeout.current && clearTimeout(timeout.current);
|
|
});
|
|
return state;
|
|
};
|
|
var useThrottleFn_default = useThrottleFn;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useTimeout.js
|
|
function useTimeout(ms) {
|
|
if (ms === void 0) {
|
|
ms = 0;
|
|
}
|
|
var update = useUpdate();
|
|
return useTimeoutFn(update, ms);
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useTitle.js
|
|
var import_react86 = __toESM(require_react());
|
|
var DEFAULT_USE_TITLE_OPTIONS = {
|
|
restoreOnUnmount: false
|
|
};
|
|
function useTitle(title, options) {
|
|
if (options === void 0) {
|
|
options = DEFAULT_USE_TITLE_OPTIONS;
|
|
}
|
|
var prevTitleRef = (0, import_react86.useRef)(document.title);
|
|
if (document.title !== title)
|
|
document.title = title;
|
|
(0, import_react86.useEffect)(function() {
|
|
if (options && options.restoreOnUnmount) {
|
|
return function() {
|
|
document.title = prevTitleRef.current;
|
|
};
|
|
} else {
|
|
return;
|
|
}
|
|
}, []);
|
|
}
|
|
var useTitle_default = typeof document !== "undefined" ? useTitle : function(_title) {
|
|
};
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useTween.js
|
|
var import_ts_easing = __toESM(require_lib2());
|
|
var useTween = function(easingName, ms, delay) {
|
|
if (easingName === void 0) {
|
|
easingName = "inCirc";
|
|
}
|
|
if (ms === void 0) {
|
|
ms = 200;
|
|
}
|
|
if (delay === void 0) {
|
|
delay = 0;
|
|
}
|
|
var fn = import_ts_easing.easing[easingName];
|
|
var t = useRaf_default(ms, delay);
|
|
if (true) {
|
|
if (typeof fn !== "function") {
|
|
console.error('useTween() expected "easingName" property to be a valid easing function name, like:"' + Object.keys(import_ts_easing.easing).join('", "') + '".');
|
|
console.trace();
|
|
return 0;
|
|
}
|
|
}
|
|
return fn(t);
|
|
};
|
|
var useTween_default = useTween;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useUnmountPromise.js
|
|
var import_react87 = __toESM(require_react());
|
|
var useUnmountPromise = function() {
|
|
var refUnmounted = (0, import_react87.useRef)(false);
|
|
useEffectOnce_default(function() {
|
|
return function() {
|
|
refUnmounted.current = true;
|
|
};
|
|
});
|
|
var wrapper = (0, import_react87.useMemo)(function() {
|
|
var race = function(promise, onError) {
|
|
var newPromise = new Promise(function(resolve, reject) {
|
|
promise.then(function(result) {
|
|
if (!refUnmounted.current)
|
|
resolve(result);
|
|
}, function(error) {
|
|
if (!refUnmounted.current)
|
|
reject(error);
|
|
else if (onError)
|
|
onError(error);
|
|
else
|
|
console.error("useUnmountPromise", error);
|
|
});
|
|
});
|
|
return newPromise;
|
|
};
|
|
return race;
|
|
}, []);
|
|
return wrapper;
|
|
};
|
|
var useUnmountPromise_default = useUnmountPromise;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useUpsert.js
|
|
init_tslib_es6();
|
|
function useUpsert(predicate, initialList) {
|
|
if (initialList === void 0) {
|
|
initialList = [];
|
|
}
|
|
var _a = useList_default(initialList), list = _a[0], listActions = _a[1];
|
|
return [
|
|
list,
|
|
__assign(__assign({}, listActions), { upsert: function(newItem) {
|
|
listActions.upsert(predicate, newItem);
|
|
} })
|
|
];
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useVibrate.js
|
|
var import_react88 = __toESM(require_react());
|
|
var isVibrationApiSupported = isNavigator && "vibrate" in navigator;
|
|
function useVibrate(enabled, pattern, loop) {
|
|
if (enabled === void 0) {
|
|
enabled = true;
|
|
}
|
|
if (pattern === void 0) {
|
|
pattern = [1e3, 1e3];
|
|
}
|
|
if (loop === void 0) {
|
|
loop = true;
|
|
}
|
|
(0, import_react88.useEffect)(function() {
|
|
var interval;
|
|
if (enabled) {
|
|
navigator.vibrate(pattern);
|
|
if (loop) {
|
|
var duration = pattern instanceof Array ? pattern.reduce(function(a, b) {
|
|
return a + b;
|
|
}) : pattern;
|
|
interval = setInterval(function() {
|
|
navigator.vibrate(pattern);
|
|
}, duration);
|
|
}
|
|
}
|
|
return function() {
|
|
if (enabled) {
|
|
navigator.vibrate(0);
|
|
if (loop) {
|
|
clearInterval(interval);
|
|
}
|
|
}
|
|
};
|
|
}, [enabled]);
|
|
}
|
|
var useVibrate_default = isVibrationApiSupported ? useVibrate : noop;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useVideo.js
|
|
var useVideo = createHTMLMediaHook("video");
|
|
var useVideo_default = useVideo;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useStateValidator.js
|
|
var import_react89 = __toESM(require_react());
|
|
function useStateValidator(state, validator, initialState) {
|
|
if (initialState === void 0) {
|
|
initialState = [void 0];
|
|
}
|
|
var validatorInner = (0, import_react89.useRef)(validator);
|
|
var stateInner = (0, import_react89.useRef)(state);
|
|
validatorInner.current = validator;
|
|
stateInner.current = state;
|
|
var _a = (0, import_react89.useState)(initialState), validity = _a[0], setValidity = _a[1];
|
|
var validate = (0, import_react89.useCallback)(function() {
|
|
if (validatorInner.current.length >= 2) {
|
|
validatorInner.current(stateInner.current, setValidity);
|
|
} else {
|
|
setValidity(validatorInner.current(stateInner.current));
|
|
}
|
|
}, [setValidity]);
|
|
(0, import_react89.useEffect)(function() {
|
|
validate();
|
|
}, [state]);
|
|
return [validity, validate];
|
|
}
|
|
|
|
// node_modules/.pnpm/@xobotyi+scrollbar-width@1.9.5/node_modules/@xobotyi/scrollbar-width/dist/index.esm.js
|
|
var e = function(t) {
|
|
if ("undefined" == typeof document) return 0;
|
|
if (document.body && (!document.readyState || "loading" !== document.readyState)) {
|
|
if (true !== t && "number" == typeof e.__cache) return e.__cache;
|
|
var o = document.createElement("div"), d = o.style;
|
|
d.display = "block", d.position = "absolute", d.width = "100px", d.height = "100px", d.left = "-999px", d.top = "-999px", d.overflow = "scroll", document.body.insertBefore(o, null);
|
|
var n = o.clientWidth;
|
|
if (0 !== n) return e.__cache = 100 - n, document.body.removeChild(o), e.__cache;
|
|
document.body.removeChild(o);
|
|
}
|
|
};
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useScrollbarWidth.js
|
|
var import_react90 = __toESM(require_react());
|
|
function useScrollbarWidth() {
|
|
var _a = (0, import_react90.useState)(e()), sbw = _a[0], setSbw = _a[1];
|
|
(0, import_react90.useEffect)(function() {
|
|
if (typeof sbw !== "undefined") {
|
|
return;
|
|
}
|
|
var raf = requestAnimationFrame(function() {
|
|
setSbw(e());
|
|
});
|
|
return function() {
|
|
return cancelAnimationFrame(raf);
|
|
};
|
|
}, []);
|
|
return sbw;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMultiStateValidator.js
|
|
var import_react91 = __toESM(require_react());
|
|
function useMultiStateValidator(states, validator, initialValidity) {
|
|
if (initialValidity === void 0) {
|
|
initialValidity = [void 0];
|
|
}
|
|
if (typeof states !== "object") {
|
|
throw new Error("states expected to be an object or array, got " + typeof states);
|
|
}
|
|
var validatorInner = (0, import_react91.useRef)(validator);
|
|
var statesInner = (0, import_react91.useRef)(states);
|
|
validatorInner.current = validator;
|
|
statesInner.current = states;
|
|
var _a = (0, import_react91.useState)(initialValidity), validity = _a[0], setValidity = _a[1];
|
|
var validate = (0, import_react91.useCallback)(function() {
|
|
if (validatorInner.current.length >= 2) {
|
|
validatorInner.current(statesInner.current, setValidity);
|
|
} else {
|
|
setValidity(validatorInner.current(statesInner.current));
|
|
}
|
|
}, [setValidity]);
|
|
(0, import_react91.useEffect)(function() {
|
|
validate();
|
|
}, Object.values(states));
|
|
return [validity, validate];
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useWindowScroll.js
|
|
var import_react92 = __toESM(require_react());
|
|
var useWindowScroll = function() {
|
|
var _a = useRafState_default(function() {
|
|
return {
|
|
x: isBrowser ? window.pageXOffset : 0,
|
|
y: isBrowser ? window.pageYOffset : 0
|
|
};
|
|
}), state = _a[0], setState = _a[1];
|
|
(0, import_react92.useEffect)(function() {
|
|
var handler = function() {
|
|
setState(function(state2) {
|
|
var pageXOffset = window.pageXOffset, pageYOffset = window.pageYOffset;
|
|
return state2.x !== pageXOffset || state2.y !== pageYOffset ? {
|
|
x: pageXOffset,
|
|
y: pageYOffset
|
|
} : state2;
|
|
});
|
|
};
|
|
handler();
|
|
on(window, "scroll", handler, {
|
|
capture: false,
|
|
passive: true
|
|
});
|
|
return function() {
|
|
off(window, "scroll", handler);
|
|
};
|
|
}, []);
|
|
return state;
|
|
};
|
|
var useWindowScroll_default = useWindowScroll;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useWindowSize.js
|
|
var import_react93 = __toESM(require_react());
|
|
var useWindowSize = function(_a) {
|
|
var _b = _a === void 0 ? {} : _a, _c = _b.initialWidth, initialWidth = _c === void 0 ? Infinity : _c, _d = _b.initialHeight, initialHeight = _d === void 0 ? Infinity : _d, onChange = _b.onChange;
|
|
var _e = useRafState_default({
|
|
width: isBrowser ? window.innerWidth : initialWidth,
|
|
height: isBrowser ? window.innerHeight : initialHeight
|
|
}), state = _e[0], setState = _e[1];
|
|
(0, import_react93.useEffect)(function() {
|
|
if (isBrowser) {
|
|
var handler_1 = function() {
|
|
var width = window.innerWidth;
|
|
var height = window.innerHeight;
|
|
setState({
|
|
width,
|
|
height
|
|
});
|
|
if (onChange)
|
|
onChange(width, height);
|
|
};
|
|
on(window, "resize", handler_1);
|
|
return function() {
|
|
off(window, "resize", handler_1);
|
|
};
|
|
}
|
|
}, []);
|
|
return state;
|
|
};
|
|
var useWindowSize_default = useWindowSize;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useMeasure.js
|
|
var import_react94 = __toESM(require_react());
|
|
var defaultState3 = {
|
|
x: 0,
|
|
y: 0,
|
|
width: 0,
|
|
height: 0,
|
|
top: 0,
|
|
left: 0,
|
|
bottom: 0,
|
|
right: 0
|
|
};
|
|
function useMeasure() {
|
|
var _a = (0, import_react94.useState)(null), element = _a[0], ref = _a[1];
|
|
var _b = (0, import_react94.useState)(defaultState3), rect = _b[0], setRect = _b[1];
|
|
var observer = (0, import_react94.useMemo)(function() {
|
|
return new window.ResizeObserver(function(entries) {
|
|
if (entries[0]) {
|
|
var _a2 = entries[0].contentRect, x = _a2.x, y = _a2.y, width = _a2.width, height = _a2.height, top_1 = _a2.top, left = _a2.left, bottom = _a2.bottom, right = _a2.right;
|
|
setRect({ x, y, width, height, top: top_1, left, bottom, right });
|
|
}
|
|
});
|
|
}, []);
|
|
useIsomorphicLayoutEffect_default(function() {
|
|
if (!element)
|
|
return;
|
|
observer.observe(element);
|
|
return function() {
|
|
observer.disconnect();
|
|
};
|
|
}, [element]);
|
|
return [ref, rect];
|
|
}
|
|
var useMeasure_default = isBrowser && typeof window.ResizeObserver !== "undefined" ? useMeasure : function() {
|
|
return [noop, defaultState3];
|
|
};
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/usePinchZoom.js
|
|
var import_react95 = __toESM(require_react());
|
|
var ZoomState;
|
|
(function(ZoomState2) {
|
|
ZoomState2["ZOOMING_IN"] = "ZOOMING_IN";
|
|
ZoomState2["ZOOMING_OUT"] = "ZOOMING_OUT";
|
|
})(ZoomState || (ZoomState = {}));
|
|
var usePinchZoom = function(ref) {
|
|
var cacheRef = (0, import_react95.useMemo)(function() {
|
|
return {
|
|
evCache: [],
|
|
prevDiff: -1
|
|
};
|
|
}, [ref.current]);
|
|
var _a = (0, import_react95.useState)(), zoomingState = _a[0], setZoomingState = _a[1];
|
|
var pointermove_handler = function(ev) {
|
|
for (var i = 0; i < cacheRef.evCache.length; i++) {
|
|
if (ev.pointerId == cacheRef.evCache[i].pointerId) {
|
|
cacheRef.evCache[i] = ev;
|
|
break;
|
|
}
|
|
}
|
|
if (cacheRef.evCache.length == 2) {
|
|
var curDiff = Math.abs(cacheRef.evCache[0].clientX - cacheRef.evCache[1].clientX);
|
|
if (cacheRef.prevDiff > 0) {
|
|
if (curDiff > cacheRef.prevDiff) {
|
|
setZoomingState([ZoomState.ZOOMING_IN, curDiff]);
|
|
}
|
|
if (curDiff < cacheRef.prevDiff) {
|
|
setZoomingState([ZoomState.ZOOMING_OUT, curDiff]);
|
|
}
|
|
}
|
|
cacheRef.prevDiff = curDiff;
|
|
}
|
|
};
|
|
var pointerdown_handler = function(ev) {
|
|
cacheRef.evCache.push(ev);
|
|
};
|
|
var pointerup_handler = function(ev) {
|
|
remove_event(ev);
|
|
if (cacheRef.evCache.length < 2) {
|
|
cacheRef.prevDiff = -1;
|
|
}
|
|
};
|
|
var remove_event = function(ev) {
|
|
for (var i = 0; i < cacheRef.evCache.length; i++) {
|
|
if (cacheRef.evCache[i].pointerId == ev.pointerId) {
|
|
cacheRef.evCache.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
(0, import_react95.useEffect)(function() {
|
|
if (ref === null || ref === void 0 ? void 0 : ref.current) {
|
|
ref.current.onpointerdown = pointerdown_handler;
|
|
ref.current.onpointermove = pointermove_handler;
|
|
ref.current.onpointerup = pointerup_handler;
|
|
ref.current.onpointercancel = pointerup_handler;
|
|
ref.current.onpointerout = pointerup_handler;
|
|
ref.current.onpointerleave = pointerup_handler;
|
|
}
|
|
}, [ref === null || ref === void 0 ? void 0 : ref.current]);
|
|
return zoomingState ? { zoomingState: zoomingState[0], pinchState: zoomingState[1] } : { zoomingState: null, pinchState: 0 };
|
|
};
|
|
var usePinchZoom_default = usePinchZoom;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useRendersCount.js
|
|
var import_react96 = __toESM(require_react());
|
|
function useRendersCount() {
|
|
return ++(0, import_react96.useRef)(0).current;
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useSet.js
|
|
init_tslib_es6();
|
|
var import_react97 = __toESM(require_react());
|
|
var useSet = function(initialSet) {
|
|
if (initialSet === void 0) {
|
|
initialSet = /* @__PURE__ */ new Set();
|
|
}
|
|
var _a = (0, import_react97.useState)(initialSet), set = _a[0], setSet = _a[1];
|
|
var stableActions = (0, import_react97.useMemo)(function() {
|
|
var add = function(item) {
|
|
return setSet(function(prevSet) {
|
|
return new Set(__spreadArrays(Array.from(prevSet), [item]));
|
|
});
|
|
};
|
|
var remove = function(item) {
|
|
return setSet(function(prevSet) {
|
|
return new Set(Array.from(prevSet).filter(function(i) {
|
|
return i !== item;
|
|
}));
|
|
});
|
|
};
|
|
var toggle = function(item) {
|
|
return setSet(function(prevSet) {
|
|
return prevSet.has(item) ? new Set(Array.from(prevSet).filter(function(i) {
|
|
return i !== item;
|
|
})) : new Set(__spreadArrays(Array.from(prevSet), [item]));
|
|
});
|
|
};
|
|
return { add, remove, toggle, reset: function() {
|
|
return setSet(initialSet);
|
|
}, clear: function() {
|
|
return setSet(/* @__PURE__ */ new Set());
|
|
} };
|
|
}, [setSet]);
|
|
var utils = __assign({ has: (0, import_react97.useCallback)(function(item) {
|
|
return set.has(item);
|
|
}, [set]) }, stableActions);
|
|
return [set, utils];
|
|
};
|
|
var useSet_default = useSet;
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/factory/createGlobalState.js
|
|
var import_react98 = __toESM(require_react());
|
|
function createGlobalState(initialState) {
|
|
var store = {
|
|
state: initialState instanceof Function ? initialState() : initialState,
|
|
setState: function(nextState) {
|
|
store.state = resolveHookState(nextState, store.state);
|
|
store.setters.forEach(function(setter) {
|
|
return setter(store.state);
|
|
});
|
|
},
|
|
setters: []
|
|
};
|
|
return function() {
|
|
var _a = (0, import_react98.useState)(store.state), globalState = _a[0], stateSetter = _a[1];
|
|
useEffectOnce_default(function() {
|
|
return function() {
|
|
store.setters = store.setters.filter(function(setter) {
|
|
return setter !== stateSetter;
|
|
});
|
|
};
|
|
});
|
|
useIsomorphicLayoutEffect_default(function() {
|
|
if (!store.setters.includes(stateSetter)) {
|
|
store.setters.push(stateSetter);
|
|
}
|
|
});
|
|
return [globalState, store.setState];
|
|
};
|
|
}
|
|
|
|
// node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.1_react@19.1.1__react@19.1.1/node_modules/react-use/esm/useHash.js
|
|
var import_react99 = __toESM(require_react());
|
|
var useHash = function() {
|
|
var _a = (0, import_react99.useState)(function() {
|
|
return window.location.hash;
|
|
}), hash = _a[0], setHash = _a[1];
|
|
var onHashChange = (0, import_react99.useCallback)(function() {
|
|
setHash(window.location.hash);
|
|
}, []);
|
|
useLifecycles_default(function() {
|
|
on(window, "hashchange", onHashChange);
|
|
}, function() {
|
|
off(window, "hashchange", onHashChange);
|
|
});
|
|
var _setHash = (0, import_react99.useCallback)(function(newHash) {
|
|
if (newHash !== hash) {
|
|
window.location.hash = newHash;
|
|
}
|
|
}, [hash]);
|
|
return [hash, _setHash];
|
|
};
|
|
export {
|
|
createBreakpoint_default as createBreakpoint,
|
|
createGlobalState,
|
|
createMemo_default as createMemo,
|
|
createReducer_default as createReducer,
|
|
createReducerContext_default as createReducerContext,
|
|
createStateContext_default as createStateContext,
|
|
ensuredForwardRef,
|
|
useAsync,
|
|
useAsyncFn,
|
|
useAsyncRetry_default as useAsyncRetry,
|
|
useAudio_default as useAudio,
|
|
useBattery_default as useBattery,
|
|
useBeforeUnload_default as useBeforeUnload,
|
|
useBoolean_default as useBoolean,
|
|
useClickAway_default as useClickAway,
|
|
useCookie_default as useCookie,
|
|
useCopyToClipboard_default as useCopyToClipboard,
|
|
useCounter,
|
|
useCss_default as useCss,
|
|
useCustomCompareEffect_default as useCustomCompareEffect,
|
|
useDebounce,
|
|
useDeepCompareEffect_default as useDeepCompareEffect,
|
|
useDefault_default as useDefault,
|
|
useDrop_default as useDrop,
|
|
useDropArea_default as useDropArea,
|
|
useEffectOnce_default as useEffectOnce,
|
|
useEnsuredForwardedRef,
|
|
useError_default as useError,
|
|
useEvent_default as useEvent,
|
|
useFavicon_default as useFavicon,
|
|
useFirstMountState,
|
|
useFullscreen_default as useFullscreen,
|
|
useGeolocation_default as useGeolocation,
|
|
useGetSet,
|
|
useGetSetState_default as useGetSetState,
|
|
useHarmonicIntervalFn_default as useHarmonicIntervalFn,
|
|
useHash,
|
|
useHover_default as useHover,
|
|
useHoverDirty_default as useHoverDirty,
|
|
useIdle_default as useIdle,
|
|
useIntersection_default as useIntersection,
|
|
useInterval_default as useInterval,
|
|
useIsomorphicLayoutEffect_default as useIsomorphicLayoutEffect,
|
|
useKey_default as useKey,
|
|
useKeyPress_default as useKeyPress,
|
|
useKeyPressEvent_default as useKeyPressEvent,
|
|
useLatest_default as useLatest,
|
|
useLifecycles_default as useLifecycles,
|
|
useList_default as useList,
|
|
useLocalStorage_default as useLocalStorage,
|
|
useLocation_default as useLocation,
|
|
useLockBodyScroll_default as useLockBodyScroll,
|
|
useLogger_default as useLogger,
|
|
useLongPress_default as useLongPress,
|
|
useMap_default as useMap,
|
|
useMeasure_default as useMeasure,
|
|
useMedia_default as useMedia,
|
|
useMediaDevices_default as useMediaDevices,
|
|
useMediatedState,
|
|
useMethods_default as useMethods,
|
|
useMotion_default as useMotion,
|
|
useMount_default as useMount,
|
|
useMountedState,
|
|
useMouse_default as useMouse,
|
|
useMouseHovered_default as useMouseHovered,
|
|
useMouseWheel_default as useMouseWheel,
|
|
useMultiStateValidator,
|
|
useNetworkState,
|
|
useNumber_default as useNumber,
|
|
useObservable_default as useObservable,
|
|
useOrientation_default as useOrientation,
|
|
usePageLeave_default as usePageLeave,
|
|
usePermission_default as usePermission,
|
|
usePinchZoom_default as usePinchZoom,
|
|
usePrevious,
|
|
usePreviousDistinct,
|
|
usePromise_default as usePromise,
|
|
useQueue_default as useQueue,
|
|
useRaf_default as useRaf,
|
|
useRafLoop,
|
|
useRafState_default as useRafState,
|
|
useRendersCount,
|
|
useScratch_default as useScratch,
|
|
useScroll_default as useScroll,
|
|
useScrollbarWidth,
|
|
useScrolling_default as useScrolling,
|
|
useSearchParam_default as useSearchParam,
|
|
useSessionStorage_default as useSessionStorage,
|
|
useSet_default as useSet,
|
|
useSetState_default as useSetState,
|
|
useShallowCompareEffect_default as useShallowCompareEffect,
|
|
useSize_default as useSize,
|
|
useSlider_default as useSlider,
|
|
useSpeech_default as useSpeech,
|
|
useStartTyping_default as useStartTyping,
|
|
useStateList,
|
|
useStateValidator,
|
|
useStateWithHistory,
|
|
useThrottle_default as useThrottle,
|
|
useThrottleFn_default as useThrottleFn,
|
|
useTimeout,
|
|
useTimeoutFn,
|
|
useTitle_default as useTitle,
|
|
useToggle_default as useToggle,
|
|
useTween_default as useTween,
|
|
useUnmount_default as useUnmount,
|
|
useUnmountPromise_default as useUnmountPromise,
|
|
useUpdate,
|
|
useUpdateEffect_default as useUpdateEffect,
|
|
useUpsert,
|
|
useVibrate_default as useVibrate,
|
|
useVideo_default as useVideo,
|
|
useWindowScroll_default as useWindowScroll,
|
|
useWindowSize_default as useWindowSize
|
|
};
|
|
/*! Bundled license information:
|
|
|
|
js-cookie/src/js.cookie.js:
|
|
(*!
|
|
* JavaScript Cookie v2.2.1
|
|
* https://github.com/js-cookie/js-cookie
|
|
*
|
|
* Copyright 2006, 2015 Klaus Hartl & Fagner Brack
|
|
* Released under the MIT license
|
|
*)
|
|
|
|
screenfull/dist/screenfull.js:
|
|
(*!
|
|
* screenfull
|
|
* v5.2.0 - 2021-11-03
|
|
* (c) Sindre Sorhus; MIT License
|
|
*)
|
|
*/
|
|
//# sourceMappingURL=react-use.js.map
|