+ 
+
+ );
\ No newline at end of file
diff --git a/.idx/jest.config.js b/.idx/jest.config.js
new file mode 100644
index 0000000..37dc7e9
--- /dev/null
+++ b/.idx/jest.config.js
@@ -0,0 +1,3 @@
+"transform": {
+ "^.+\\.jsx?$": "./path/to/wrapper.js"
+},
\ No newline at end of file
diff --git a/.idx/mission.js b/.idx/mission.js
new file mode 100644
index 0000000..3147fee
--- /dev/null
+++ b/.idx/mission.js
@@ -0,0 +1,62 @@
+// mission.js
+
+// Function to define a mission
+function createMission(title, description, dueDate) {
+ return {
+ title: title,
+ description: description,
+ dueDate: dueDate,
+ completed: false,
+ };
+}
+
+// Function to mark a mission as completed
+// Duplicate function removed
+
+// Example usage
+const mission1 = createMission(
+ "Chef",
+ "Prepare a delicious meal",
+ "2025-12-31"
+);
+
+console.log("Before completing:", mission1);
+completeMission(mission1);
+console.log("After completing:", mission1);
+
+export { createMission, completeMission };
+
+function completeMission(mission) {
+ mission.completed = true;
+}
+
+// Example usage
+const MISSION2 = createMission(
+ "Housekeeping",
+ "Clean the residence",
+ "2025-12-31"
+);
+
+const MISSION3 = createMission(
+ "purchasing/hr",
+ "",
+ "2025-12-31"
+);
+
+const MISSION4 = createMission(
+ "Nanny",
+ "Take care of the children",
+ "2025-12-31"
+);
+
+const UNUSED_MISSION5 = createMission(
+ "Gardening",
+ "Maintain the garden",
+ "2025-12-31"
+);
+
+const MISSION6 = createMission(
+ "Chef",
+ "Prepare a delicious meal",
+ "2025-12-31"
+);
diff --git a/.idx/my-babel-plugin.js b/.idx/my-babel-plugin.js
new file mode 100644
index 0000000..c998d14
--- /dev/null
+++ b/.idx/my-babel-plugin.js
@@ -0,0 +1,38 @@
+{
+ "chrome": "60",
+ "opera": "47",
+ "edge": "79",
+ "firefox": "55",
+ "safari": "11.1",
+ "node": "8.3",
+ "deno": "1",
+ "ios": "11.3",
+ "samsung": "8",
+ "opera_mobile": "44",
+ "electron": "2.0"
+}
+import { isRequired } from "@babel/helper-compilation-targets";
+
+module.exports = api => {
+ // Check if the targets have native object-rest-spread support
+ const objectRestSpreadSupported = !isRequired(
+ "transform-object-rest-spread",
+ api.targets()
+ );
+};
+import {
+ isIdentifierName,
+ isIdentifierStart,
+ isIdentifierChar,
+ isReservedWord,
+ isStrictBindOnlyReservedWord,
+ isStrictBindReservedWord,
+ isStrictReservedWord,
+ isKeyword,
+ } from "@babel/helper-validator-identifier";
+ import environmentVisitor, {
+ requeueComputedKeyAndDecorators
+ } from "@babel/helper-environment-visitor";
+ if (path.isMethod()) {
+ requeueComputedKeyAndDecorators(path)
+ }
\ No newline at end of file
diff --git a/.idx/node/assert.js b/.idx/node/assert.js
new file mode 100644
index 0000000..71dbc60
--- /dev/null
+++ b/.idx/node/assert.js
@@ -0,0 +1,176 @@
+'use strict';
+const {
+ ArrayPrototypeForEach,
+ ArrayPrototypeMap,
+ ArrayPrototypePush,
+ FunctionPrototypeBind,
+ ObjectEntries,
+ String,
+ Symbol,
+} = primordials;
+
+const {
+ ERR_INVALID_ARG_VALUE,
+ ERR_WASI_ALREADY_STARTED,
+} = require('internal/errors').codes;
+const {
+ emitExperimentalWarning,
+ kEmptyObject,
+} = require('internal/util');
+const {
+ validateArray,
+ validateBoolean,
+ validateFunction,
+ validateInt32,
+ validateObject,
+ validateString,
+ validateUndefined,
+} = require('internal/validators');
+const kExitCode = Symbol('kExitCode');
+const kSetMemory = Symbol('kSetMemory');
+const kStarted = Symbol('kStarted');
+const kInstance = Symbol('kInstance');
+const kBindingName = Symbol('kBindingName');
+
+emitExperimentalWarning('WASI');
+
+class WASI {
+ constructor(options = kEmptyObject) {
+ validateObject(options, 'options');
+
+ let _WASI;
+ validateString(options.version, 'options.version');
+ switch (options.version) {
+ case 'unstable':
+ ({ WASI: _WASI } = internalBinding('wasi'));
+ this[kBindingName] = 'wasi_unstable';
+ break;
+ case 'preview1':
+ ({ WASI: _WASI } = internalBinding('wasi'));
+ this[kBindingName] = 'wasi_snapshot_preview1';
+ break;
+ // When adding support for additional wasi versions add case here
+ default:
+ throw new ERR_INVALID_ARG_VALUE('options.version',
+ options.version,
+ 'unsupported WASI version');
+ }
+
+ if (options.args !== undefined)
+ validateArray(options.args, 'options.args');
+ const args = ArrayPrototypeMap(options.args || [], String);
+
+ const env = [];
+ if (options.env !== undefined) {
+ validateObject(options.env, 'options.env');
+ ArrayPrototypeForEach(
+ ObjectEntries(options.env),
+ ({ 0: key, 1: value }) => {
+ if (value !== undefined)
+ ArrayPrototypePush(env, `${key}=${value}`);
+ });
+ }
+
+ const preopens = [];
+ if (options.preopens !== undefined) {
+ validateObject(options.preopens, 'options.preopens');
+ ArrayPrototypeForEach(
+ ObjectEntries(options.preopens),
+ ({ 0: key, 1: value }) =>
+ ArrayPrototypePush(preopens, String(key), String(value)),
+ );
+ }
+
+ const { stdin = 0, stdout = 1, stderr = 2 } = options;
+ validateInt32(stdin, 'options.stdin', 0);
+ validateInt32(stdout, 'options.stdout', 0);
+ validateInt32(stderr, 'options.stderr', 0);
+ const stdio = [stdin, stdout, stderr];
+
+ const wrap = new _WASI(args, env, preopens, stdio);
+
+ for (const prop in wrap) {
+ wrap[prop] = FunctionPrototypeBind(wrap[prop], wrap);
+ }
+
+ let returnOnExit = true;
+ if (options.returnOnExit !== undefined) {
+ validateBoolean(options.returnOnExit, 'options.returnOnExit');
+ returnOnExit = options.returnOnExit;
+ }
+ if (returnOnExit)
+ wrap.proc_exit = FunctionPrototypeBind(wasiReturnOnProcExit, this);
+
+ this[kSetMemory] = wrap._setMemory;
+ delete wrap._setMemory;
+ this.wasiImport = wrap;
+ this[kStarted] = false;
+ this[kExitCode] = 0;
+ this[kInstance] = undefined;
+ }
+
+ finalizeBindings(instance, {
+ memory = instance?.exports?.memory,
+ } = {}) {
+ if (this[kStarted]) {
+ throw new ERR_WASI_ALREADY_STARTED();
+ }
+
+ validateObject(instance, 'instance');
+ validateObject(instance.exports, 'instance.exports');
+
+ this[kSetMemory](memory);
+
+ this[kInstance] = instance;
+ this[kStarted] = true;
+ }
+
+ // Must not export _initialize, must export _start
+ start(instance) {
+ this.finalizeBindings(instance);
+
+ const { _start, _initialize } = this[kInstance].exports;
+
+ validateFunction(_start, 'instance.exports._start');
+ validateUndefined(_initialize, 'instance.exports._initialize');
+
+ try {
+ _start();
+ } catch (err) {
+ if (err !== kExitCode) {
+ throw err;
+ }
+ }
+
+ return this[kExitCode];
+ }
+
+ // Must not export _start, may optionally export _initialize
+ initialize(instance) {
+ this.finalizeBindings(instance);
+
+ const { _start, _initialize } = this[kInstance].exports;
+
+ validateUndefined(_start, 'instance.exports._start');
+ if (_initialize !== undefined) {
+ validateFunction(_initialize, 'instance.exports._initialize');
+ _initialize();
+ }
+ }
+
+ getImportObject() {
+ return { [this[kBindingName]]: this.wasiImport };
+ }
+}
+
+module.exports = { WASI };
+
+
+function wasiReturnOnProcExit(rval) {
+ // If __wasi_proc_exit() does not terminate the process, an assertion is
+ // triggered in the wasm runtime. Node can sidestep the assertion and return
+ // an exit code by recording the exit code, and throwing a JavaScript
+ // exception that WebAssembly cannot catch.
+ this[kExitCode] = rval;
+ throw kExitCode;
+}
\ No newline at end of file
diff --git a/.idx/node/async_hooks.js b/.idx/node/async_hooks.js
new file mode 100644
index 0000000..8c57bc6
--- /dev/null
+++ b/.idx/node/async_hooks.js
@@ -0,0 +1,296 @@
+'use strict';
+
+const {
+ ArrayPrototypeIncludes,
+ ArrayPrototypeIndexOf,
+ ArrayPrototypePush,
+ ArrayPrototypeSplice,
+ ArrayPrototypeUnshift,
+ FunctionPrototypeBind,
+ NumberIsSafeInteger,
+ ObjectDefineProperties,
+ ObjectFreeze,
+ ReflectApply,
+ Symbol,
+} = primordials;
+
+const {
+ ERR_ASYNC_CALLBACK,
+ ERR_ASYNC_TYPE,
+ ERR_INVALID_ASYNC_ID,
+} = require('internal/errors').codes;
+const {
+ deprecate,
+ kEmptyObject,
+} = require('internal/util');
+const {
+ validateFunction,
+ validateString,
+} = require('internal/validators');
+const internal_async_hooks = require('internal/async_hooks');
+
+const AsyncContextFrame = require('internal/async_context_frame');
+
+// Get functions
+// For userland AsyncResources, make sure to emit a destroy event when the
+// resource gets gced.
+const { registerDestroyHook, kNoPromiseHook } = internal_async_hooks;
+const {
+ asyncWrap,
+ executionAsyncId,
+ triggerAsyncId,
+ // Private API
+ hasAsyncIdStack,
+ getHookArrays,
+ enableHooks,
+ disableHooks,
+ updatePromiseHookMode,
+ executionAsyncResource,
+ // Internal Embedder API
+ newAsyncId,
+ getDefaultTriggerAsyncId,
+ emitInit,
+ emitBefore,
+ emitAfter,
+ emitDestroy,
+ enabledHooksExist,
+ initHooksExist,
+ destroyHooksExist,
+} = internal_async_hooks;
+
+// Get symbols
+const {
+ async_id_symbol, trigger_async_id_symbol,
+ init_symbol, before_symbol, after_symbol, destroy_symbol,
+ promise_resolve_symbol,
+} = internal_async_hooks.symbols;
+
+// Get constants
+const {
+ kInit, kBefore, kAfter, kDestroy, kTotals, kPromiseResolve,
+} = internal_async_hooks.constants;
+
+// Listener API //
+
+class AsyncHook {
+ constructor({ init, before, after, destroy, promiseResolve }) {
+ if (init !== undefined && typeof init !== 'function')
+ throw new ERR_ASYNC_CALLBACK('hook.init');
+ if (before !== undefined && typeof before !== 'function')
+ throw new ERR_ASYNC_CALLBACK('hook.before');
+ if (after !== undefined && typeof after !== 'function')
+ throw new ERR_ASYNC_CALLBACK('hook.after');
+ if (destroy !== undefined && typeof destroy !== 'function')
+ throw new ERR_ASYNC_CALLBACK('hook.destroy');
+ if (promiseResolve !== undefined && typeof promiseResolve !== 'function')
+ throw new ERR_ASYNC_CALLBACK('hook.promiseResolve');
+
+ this[init_symbol] = init;
+ this[before_symbol] = before;
+ this[after_symbol] = after;
+ this[destroy_symbol] = destroy;
+ this[promise_resolve_symbol] = promiseResolve;
+ this[kNoPromiseHook] = false;
+ }
+
+ enable() {
+ // The set of callbacks for a hook should be the same regardless of whether
+ // enable()/disable() are run during their execution. The following
+ // references are reassigned to the tmp arrays if a hook is currently being
+ // processed.
+ const { 0: hooks_array, 1: hook_fields } = getHookArrays();
+
+ // Each hook is only allowed to be added once.
+ if (ArrayPrototypeIncludes(hooks_array, this))
+ return this;
+
+ const prev_kTotals = hook_fields[kTotals];
+
+ // createHook() has already enforced that the callbacks are all functions,
+ // so here simply increment the count of whether each callbacks exists or
+ // not.
+ hook_fields[kTotals] = hook_fields[kInit] += +!!this[init_symbol];
+ hook_fields[kTotals] += hook_fields[kBefore] += +!!this[before_symbol];
+ hook_fields[kTotals] += hook_fields[kAfter] += +!!this[after_symbol];
+ hook_fields[kTotals] += hook_fields[kDestroy] += +!!this[destroy_symbol];
+ hook_fields[kTotals] +=
+ hook_fields[kPromiseResolve] += +!!this[promise_resolve_symbol];
+ ArrayPrototypePush(hooks_array, this);
+
+ if (prev_kTotals === 0 && hook_fields[kTotals] > 0) {
+ enableHooks();
+ }
+
+ if (!this[kNoPromiseHook]) {
+ updatePromiseHookMode();
+ }
+
+ return this;
+ }
+
+ disable() {
+ const { 0: hooks_array, 1: hook_fields } = getHookArrays();
+
+ const index = ArrayPrototypeIndexOf(hooks_array, this);
+ if (index === -1)
+ return this;
+
+ const prev_kTotals = hook_fields[kTotals];
+
+ hook_fields[kTotals] = hook_fields[kInit] -= +!!this[init_symbol];
+ hook_fields[kTotals] += hook_fields[kBefore] -= +!!this[before_symbol];
+ hook_fields[kTotals] += hook_fields[kAfter] -= +!!this[after_symbol];
+ hook_fields[kTotals] += hook_fields[kDestroy] -= +!!this[destroy_symbol];
+ hook_fields[kTotals] +=
+ hook_fields[kPromiseResolve] -= +!!this[promise_resolve_symbol];
+ ArrayPrototypeSplice(hooks_array, index, 1);
+
+ if (prev_kTotals > 0 && hook_fields[kTotals] === 0) {
+ disableHooks();
+ }
+
+ return this;
+ }
+}
+
+
+function createHook(fns) {
+ return new AsyncHook(fns);
+}
+
+
+// Embedder API //
+
+const destroyedSymbol = Symbol('destroyed');
+const contextFrameSymbol = Symbol('context_frame');
+
+class AsyncResource {
+ constructor(type, opts = kEmptyObject) {
+ validateString(type, 'type');
+
+ let triggerAsyncId = opts;
+ let requireManualDestroy = false;
+ if (typeof opts !== 'number') {
+ triggerAsyncId = opts.triggerAsyncId === undefined ?
+ getDefaultTriggerAsyncId() : opts.triggerAsyncId;
+ requireManualDestroy = !!opts.requireManualDestroy;
+ }
+
+ // Unlike emitInitScript, AsyncResource doesn't supports null as the
+ // triggerAsyncId.
+ if (!NumberIsSafeInteger(triggerAsyncId) || triggerAsyncId < -1) {
+ throw new ERR_INVALID_ASYNC_ID('triggerAsyncId', triggerAsyncId);
+ }
+
+ this[contextFrameSymbol] = AsyncContextFrame.current();
+
+ const asyncId = newAsyncId();
+ this[async_id_symbol] = asyncId;
+ this[trigger_async_id_symbol] = triggerAsyncId;
+
+ if (initHooksExist()) {
+ if (enabledHooksExist() && type.length === 0) {
+ throw new ERR_ASYNC_TYPE(type);
+ }
+
+ emitInit(asyncId, type, triggerAsyncId, this);
+ }
+
+ if (!requireManualDestroy && destroyHooksExist()) {
+ // This prop name (destroyed) has to be synchronized with C++
+ const destroyed = { destroyed: false };
+ this[destroyedSymbol] = destroyed;
+ registerDestroyHook(this, asyncId, destroyed);
+ }
+ }
+
+ runInAsyncScope(fn, thisArg, ...args) {
+ const asyncId = this[async_id_symbol];
+ emitBefore(asyncId, this[trigger_async_id_symbol], this);
+
+ const contextFrame = this[contextFrameSymbol];
+ const prior = AsyncContextFrame.exchange(contextFrame);
+ try {
+ return ReflectApply(fn, thisArg, args);
+ } finally {
+ AsyncContextFrame.set(prior);
+ if (hasAsyncIdStack())
+ emitAfter(asyncId);
+ }
+ }
+
+ emitDestroy() {
+ if (this[destroyedSymbol] !== undefined) {
+ this[destroyedSymbol].destroyed = true;
+ }
+ emitDestroy(this[async_id_symbol]);
+ return this;
+ }
+
+ asyncId() {
+ return this[async_id_symbol];
+ }
+
+ triggerAsyncId() {
+ return this[trigger_async_id_symbol];
+ }
+
+ bind(fn, thisArg) {
+ validateFunction(fn, 'fn');
+ let bound;
+ if (thisArg === undefined) {
+ const resource = this;
+ bound = function(...args) {
+ ArrayPrototypeUnshift(args, fn, this);
+ return ReflectApply(resource.runInAsyncScope, resource, args);
+ };
+ } else {
+ bound = FunctionPrototypeBind(this.runInAsyncScope, this, fn, thisArg);
+ }
+ let self = this;
+ ObjectDefineProperties(bound, {
+ 'length': {
+ __proto__: null,
+ configurable: true,
+ enumerable: false,
+ value: fn.length,
+ writable: false,
+ },
+ 'asyncResource': {
+ __proto__: null,
+ configurable: true,
+ enumerable: true,
+ get: deprecate(function() {
+ return self;
+ }, 'The asyncResource property on bound functions is deprecated', 'DEP0172'),
+ set: deprecate(function(val) {
+ self = val;
+ }, 'The asyncResource property on bound functions is deprecated', 'DEP0172'),
+ },
+ });
+ return bound;
+ }
+
+ static bind(fn, type, thisArg) {
+ type ||= fn.name;
+ return (new AsyncResource(type || 'bound-anonymous-fn')).bind(fn, thisArg);
+ }
+}
+
+// Placing all exports down here because the exported classes won't export
+// otherwise.
+module.exports = {
+ // Public API
+ get AsyncLocalStorage() {
+ return AsyncContextFrame.enabled ?
+ require('internal/async_local_storage/async_context_frame') :
+ require('internal/async_local_storage/async_hooks');
+ },
+ createHook,
+ executionAsyncId,
+ triggerAsyncId,
+ executionAsyncResource,
+ asyncWrapProviders: ObjectFreeze({ __proto__: null, ...asyncWrap.Providers }),
+ // Embedder API
+ AsyncResource,
+};
\ No newline at end of file
diff --git a/.idx/node/buffer.js b/.idx/node/buffer.js
new file mode 100644
index 0000000..06bfebc
--- /dev/null
+++ b/.idx/node/buffer.js
@@ -0,0 +1,1365 @@
+'use strict';
+
+const {
+ Array,
+ ArrayBufferIsView,
+ ArrayIsArray,
+ ArrayPrototypeForEach,
+ MathFloor,
+ MathMin,
+ MathTrunc,
+ NumberIsInteger,
+ NumberIsNaN,
+ NumberMAX_SAFE_INTEGER,
+ NumberMIN_SAFE_INTEGER,
+ ObjectDefineProperties,
+ ObjectDefineProperty,
+ ObjectPrototypeHasOwnProperty,
+ ObjectSetPrototypeOf,
+ RegExpPrototypeSymbolReplace,
+ StringPrototypeCharCodeAt,
+ StringPrototypeSlice,
+ StringPrototypeToLowerCase,
+ StringPrototypeTrim,
+ SymbolSpecies,
+ SymbolToPrimitive,
+ TypedArrayPrototypeFill,
+ TypedArrayPrototypeGetBuffer,
+ TypedArrayPrototypeGetByteLength,
+ TypedArrayPrototypeGetByteOffset,
+ TypedArrayPrototypeGetLength,
+ TypedArrayPrototypeSet,
+ TypedArrayPrototypeSlice,
+ Uint8Array,
+ Uint8ArrayPrototype,
+} = primordials;
+
+const {
+ byteLengthUtf8,
+ compare: _compare,
+ compareOffset,
+ copy: _copy,
+ fill: bindingFill,
+ isAscii: bindingIsAscii,
+ isUtf8: bindingIsUtf8,
+ indexOfBuffer,
+ indexOfNumber,
+ indexOfString,
+ swap16: _swap16,
+ swap32: _swap32,
+ swap64: _swap64,
+ kMaxLength,
+ kStringMaxLength,
+ atob: _atob,
+ btoa: _btoa,
+} = internalBinding('buffer');
+const {
+ constants: {
+ ALL_PROPERTIES,
+ ONLY_ENUMERABLE,
+ },
+ getOwnNonIndexProperties,
+ isInsideNodeModules,
+} = internalBinding('util');
+const {
+ customInspectSymbol,
+ lazyDOMException,
+ normalizeEncoding,
+ kIsEncodingSymbol,
+ defineLazyProperties,
+ encodingsMap,
+ deprecate,
+} = require('internal/util');
+const {
+ isAnyArrayBuffer,
+ isArrayBufferView,
+ isUint8Array,
+ isTypedArray,
+} = require('internal/util/types');
+const {
+ inspect: utilInspect,
+} = require('internal/util/inspect');
+
+const {
+ codes: {
+ ERR_BUFFER_OUT_OF_BOUNDS,
+ ERR_INVALID_ARG_TYPE,
+ ERR_INVALID_ARG_VALUE,
+ ERR_INVALID_BUFFER_SIZE,
+ ERR_MISSING_ARGS,
+ ERR_OUT_OF_RANGE,
+ ERR_UNKNOWN_ENCODING,
+ },
+ genericNodeError,
+} = require('internal/errors');
+const {
+ validateArray,
+ validateBuffer,
+ validateInteger,
+ validateNumber,
+ validateString,
+} = require('internal/validators');
+// Provide validateInteger() but with kMaxLength as the default maximum value.
+const validateOffset = (value, name, min = 0, max = kMaxLength) =>
+ validateInteger(value, name, min, max);
+
+const {
+ FastBuffer,
+ markAsUntransferable,
+ addBufferPrototypeMethods,
+ createUnsafeBuffer,
+} = require('internal/buffer');
+
+FastBuffer.prototype.constructor = Buffer;
+Buffer.prototype = FastBuffer.prototype;
+addBufferPrototypeMethods(Buffer.prototype);
+
+const constants = ObjectDefineProperties({}, {
+ MAX_LENGTH: {
+ __proto__: null,
+ value: kMaxLength,
+ writable: false,
+ enumerable: true,
+ },
+ MAX_STRING_LENGTH: {
+ __proto__: null,
+ value: kStringMaxLength,
+ writable: false,
+ enumerable: true,
+ },
+});
+
+Buffer.poolSize = 8 * 1024;
+let poolSize, poolOffset, allocPool, allocBuffer;
+
+function createPool() {
+ poolSize = Buffer.poolSize;
+ allocBuffer = createUnsafeBuffer(poolSize);
+ allocPool = allocBuffer.buffer;
+ markAsUntransferable(allocPool);
+ poolOffset = 0;
+}
+createPool();
+
+function alignPool() {
+ // Ensure aligned slices
+ if (poolOffset & 0x7) {
+ poolOffset |= 0x7;
+ poolOffset++;
+ }
+}
+
+let bufferWarningAlreadyEmitted = false;
+let nodeModulesCheckCounter = 0;
+const bufferWarning = 'Buffer() is deprecated due to security and usability ' +
+ 'issues. Please use the Buffer.alloc(), ' +
+ 'Buffer.allocUnsafe(), or Buffer.from() methods instead.';
+
+function showFlaggedDeprecation() {
+ if (bufferWarningAlreadyEmitted ||
+ ++nodeModulesCheckCounter > 10000 ||
+ (!require('internal/options').getOptionValue('--pending-deprecation') &&
+ isInsideNodeModules(100, true))) {
+ // We don't emit a warning, because we either:
+ // - Already did so, or
+ // - Already checked too many times whether a call is coming
+ // from node_modules and want to stop slowing down things, or
+ // - We aren't running with `--pending-deprecation` enabled,
+ // and the code is inside `node_modules`.
+ // - We found node_modules in up to the topmost 100 frames, or
+ // there are more than 100 frames and we don't want to search anymore.
+ return;
+ }
+
+ process.emitWarning(bufferWarning, 'DeprecationWarning', 'DEP0005');
+ bufferWarningAlreadyEmitted = true;
+}
+
+function toInteger(n, defaultVal) {
+ n = +n;
+ if (!NumberIsNaN(n) &&
+ n >= NumberMIN_SAFE_INTEGER &&
+ n <= NumberMAX_SAFE_INTEGER) {
+ return ((n % 1) === 0 ? n : MathFloor(n));
+ }
+ return defaultVal;
+}
+
+function copyImpl(source, target, targetStart, sourceStart, sourceEnd) {
+ if (!ArrayBufferIsView(source))
+ throw new ERR_INVALID_ARG_TYPE('source', ['Buffer', 'Uint8Array'], source);
+ if (!ArrayBufferIsView(target))
+ throw new ERR_INVALID_ARG_TYPE('target', ['Buffer', 'Uint8Array'], target);
+
+ if (targetStart === undefined) {
+ targetStart = 0;
+ } else {
+ targetStart = NumberIsInteger(targetStart) ? targetStart : toInteger(targetStart, 0);
+ if (targetStart < 0)
+ throw new ERR_OUT_OF_RANGE('targetStart', '>= 0', targetStart);
+ }
+
+ if (sourceStart === undefined) {
+ sourceStart = 0;
+ } else {
+ sourceStart = NumberIsInteger(sourceStart) ? sourceStart : toInteger(sourceStart, 0);
+ if (sourceStart < 0 || sourceStart > source.byteLength)
+ throw new ERR_OUT_OF_RANGE('sourceStart', `>= 0 && <= ${source.byteLength}`, sourceStart);
+ }
+
+ if (sourceEnd === undefined) {
+ sourceEnd = source.byteLength;
+ } else {
+ sourceEnd = NumberIsInteger(sourceEnd) ? sourceEnd : toInteger(sourceEnd, 0);
+ if (sourceEnd < 0)
+ throw new ERR_OUT_OF_RANGE('sourceEnd', '>= 0', sourceEnd);
+ }
+
+ if (targetStart >= target.byteLength || sourceStart >= sourceEnd)
+ return 0;
+
+ return _copyActual(source, target, targetStart, sourceStart, sourceEnd);
+}
+
+function _copyActual(source, target, targetStart, sourceStart, sourceEnd) {
+ if (sourceEnd - sourceStart > target.byteLength - targetStart)
+ sourceEnd = sourceStart + target.byteLength - targetStart;
+
+ let nb = sourceEnd - sourceStart;
+ const sourceLen = source.byteLength - sourceStart;
+ if (nb > sourceLen)
+ nb = sourceLen;
+
+ if (nb <= 0)
+ return 0;
+
+ _copy(source, target, targetStart, sourceStart, nb);
+
+ return nb;
+}
+
+/**
+ * The Buffer() constructor is deprecated in documentation and should not be
+ * used moving forward. Rather, developers should use one of the three new
+ * factory APIs: Buffer.from(), Buffer.allocUnsafe() or Buffer.alloc() based on
+ * their specific needs. There is no runtime deprecation because of the extent
+ * to which the Buffer constructor is used in the ecosystem currently -- a
+ * runtime deprecation would introduce too much breakage at this time. It's not
+ * likely that the Buffer constructors would ever actually be removed.
+ * Deprecation Code: DEP0005
+ * @returns {Buffer}
+ */
+function Buffer(arg, encodingOrOffset, length) {
+ showFlaggedDeprecation();
+ // Common case.
+ if (typeof arg === 'number') {
+ if (typeof encodingOrOffset === 'string') {
+ throw new ERR_INVALID_ARG_TYPE('string', 'string', arg);
+ }
+ return Buffer.alloc(arg);
+ }
+ return Buffer.from(arg, encodingOrOffset, length);
+}
+
+ObjectDefineProperty(Buffer, SymbolSpecies, {
+ __proto__: null,
+ enumerable: false,
+ configurable: true,
+ get() { return FastBuffer; },
+});
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ * @param {any} value
+ * @param {BufferEncoding|number} encodingOrOffset
+ * @param {number} [length]
+ * @returns {Buffer}
+ */
+Buffer.from = function from(value, encodingOrOffset, length) {
+ if (typeof value === 'string')
+ return fromString(value, encodingOrOffset);
+
+ if (typeof value === 'object' && value !== null) {
+ if (isAnyArrayBuffer(value))
+ return fromArrayBuffer(value, encodingOrOffset, length);
+
+ const valueOf = value.valueOf && value.valueOf();
+ if (valueOf != null &&
+ valueOf !== value &&
+ (typeof valueOf === 'string' || typeof valueOf === 'object')) {
+ return from(valueOf, encodingOrOffset, length);
+ }
+
+ const b = fromObject(value);
+ if (b)
+ return b;
+
+ if (typeof value[SymbolToPrimitive] === 'function') {
+ const primitive = value[SymbolToPrimitive]('string');
+ if (typeof primitive === 'string') {
+ return fromString(primitive, encodingOrOffset);
+ }
+ }
+ }
+
+ throw new ERR_INVALID_ARG_TYPE(
+ 'first argument',
+ ['string', 'Buffer', 'ArrayBuffer', 'Array', 'Array-like Object'],
+ value,
+ );
+};
+
+/**
+ * Creates the Buffer as a copy of the underlying ArrayBuffer of the view
+ * rather than the contents of the view.
+ * @param {TypedArray} view
+ * @param {number} [offset]
+ * @param {number} [length]
+ * @returns {Buffer}
+ */
+Buffer.copyBytesFrom = function copyBytesFrom(view, offset, length) {
+ if (!isTypedArray(view)) {
+ throw new ERR_INVALID_ARG_TYPE('view', [ 'TypedArray' ], view);
+ }
+
+ const viewLength = TypedArrayPrototypeGetLength(view);
+ if (viewLength === 0) {
+ return Buffer.alloc(0);
+ }
+
+ if (offset !== undefined || length !== undefined) {
+ if (offset !== undefined) {
+ validateInteger(offset, 'offset', 0);
+ if (offset >= viewLength) return Buffer.alloc(0);
+ } else {
+ offset = 0;
+ }
+ let end;
+ if (length !== undefined) {
+ validateInteger(length, 'length', 0);
+ end = offset + length;
+ } else {
+ end = viewLength;
+ }
+
+ view = TypedArrayPrototypeSlice(view, offset, end);
+ }
+
+ return fromArrayLike(new Uint8Array(
+ TypedArrayPrototypeGetBuffer(view),
+ TypedArrayPrototypeGetByteOffset(view),
+ TypedArrayPrototypeGetByteLength(view)));
+};
+
+// Identical to the built-in %TypedArray%.of(), but avoids using the deprecated
+// Buffer() constructor. Must use arrow function syntax to avoid automatically
+// adding a `prototype` property and making the function a constructor.
+//
+// Refs: https://tc39.github.io/ecma262/#sec-%typedarray%.of
+// Refs: https://esdiscuss.org/topic/isconstructor#content-11
+const of = (...items) => {
+ const newObj = createUnsafeBuffer(items.length);
+ for (let k = 0; k < items.length; k++)
+ newObj[k] = items[k];
+ return newObj;
+};
+Buffer.of = of;
+
+ObjectSetPrototypeOf(Buffer, Uint8Array);
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ * @returns {FastBuffer}
+ */
+Buffer.alloc = function alloc(size, fill, encoding) {
+ validateNumber(size, 'size', 0, kMaxLength);
+ if (fill !== undefined && fill !== 0 && size > 0) {
+ const buf = createUnsafeBuffer(size);
+ return _fill(buf, fill, 0, buf.length, encoding);
+ }
+ return new FastBuffer(size);
+};
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer
+ * instance. If `--zero-fill-buffers` is set, will zero-fill the buffer.
+ * @returns {FastBuffer}
+ */
+Buffer.allocUnsafe = function allocUnsafe(size) {
+ validateNumber(size, 'size', 0, kMaxLength);
+ return allocate(size);
+};
+
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled
+ * Buffer instance that is not allocated off the pre-initialized pool.
+ * If `--zero-fill-buffers` is set, will zero-fill the buffer.
+ * @param {number} size
+ * @returns {FastBuffer|undefined}
+ */
+Buffer.allocUnsafeSlow = function allocUnsafeSlow(size) {
+ validateNumber(size, 'size', 0, kMaxLength);
+ return createUnsafeBuffer(size);
+};
+
+// If --zero-fill-buffers command line argument is set, a zero-filled
+// buffer is returned.
+function SlowBuffer(size) {
+ validateNumber(size, 'size', 0, kMaxLength);
+ return createUnsafeBuffer(size);
+}
+
+ObjectSetPrototypeOf(SlowBuffer.prototype, Uint8ArrayPrototype);
+ObjectSetPrototypeOf(SlowBuffer, Uint8Array);
+
+function allocate(size) {
+ if (size <= 0) {
+ return new FastBuffer();
+ }
+ if (size < (Buffer.poolSize >>> 1)) {
+ if (size > (poolSize - poolOffset))
+ createPool();
+ const b = new FastBuffer(allocPool, poolOffset, size);
+ poolOffset += size;
+ alignPool();
+ return b;
+ }
+ return createUnsafeBuffer(size);
+}
+
+function fromStringFast(string, ops) {
+ const maxLength = Buffer.poolSize >>> 1;
+
+ let length = string.length; // Min length
+
+ if (length >= maxLength)
+ return createFromString(string, ops);
+
+ length *= 4; // Max length (4 bytes per character)
+
+ if (length >= maxLength)
+ length = ops.byteLength(string); // Actual length
+
+ if (length >= maxLength)
+ return createFromString(string, ops, length);
+
+ if (length > (poolSize - poolOffset))
+ createPool();
+
+ const actual = ops.write(allocBuffer, string, poolOffset, length);
+ const b = new FastBuffer(allocPool, poolOffset, actual);
+
+ poolOffset += actual;
+ alignPool();
+ return b;
+}
+
+function createFromString(string, ops, length = ops.byteLength(string)) {
+ const buf = Buffer.allocUnsafeSlow(length);
+ const actual = ops.write(buf, string, 0, length);
+ return actual < length ? new FastBuffer(buf.buffer, 0, actual) : buf;
+}
+
+function fromString(string, encoding) {
+ let ops;
+ if (!encoding || encoding === 'utf8' || typeof encoding !== 'string') {
+ ops = encodingOps.utf8;
+ } else {
+ ops = getEncodingOps(encoding);
+ if (ops === undefined)
+ throw new ERR_UNKNOWN_ENCODING(encoding);
+ }
+
+ return string.length === 0 ? new FastBuffer() : fromStringFast(string, ops);
+}
+
+function fromArrayBuffer(obj, byteOffset, length) {
+ // Convert byteOffset to integer
+ if (byteOffset === undefined) {
+ byteOffset = 0;
+ } else {
+ byteOffset = +byteOffset;
+ if (NumberIsNaN(byteOffset))
+ byteOffset = 0;
+ }
+
+ const maxLength = obj.byteLength - byteOffset;
+
+ if (maxLength < 0)
+ throw new ERR_BUFFER_OUT_OF_BOUNDS('offset');
+
+ if (length !== undefined) {
+ // Convert length to non-negative integer.
+ length = +length;
+ if (length > 0) {
+ if (length > maxLength)
+ throw new ERR_BUFFER_OUT_OF_BOUNDS('length');
+ } else {
+ length = 0;
+ }
+ }
+
+ return new FastBuffer(obj, byteOffset, length);
+}
+
+function fromArrayLike(obj) {
+ if (obj.length <= 0)
+ return new FastBuffer();
+ if (obj.length < (Buffer.poolSize >>> 1)) {
+ if (obj.length > (poolSize - poolOffset))
+ createPool();
+ const b = new FastBuffer(allocPool, poolOffset, obj.length);
+ TypedArrayPrototypeSet(b, obj, 0);
+ poolOffset += obj.length;
+ alignPool();
+ return b;
+ }
+ return new FastBuffer(obj);
+}
+
+function fromObject(obj) {
+ if (obj.length !== undefined || isAnyArrayBuffer(obj.buffer)) {
+ if (typeof obj.length !== 'number') {
+ return new FastBuffer();
+ }
+ return fromArrayLike(obj);
+ }
+
+ if (obj.type === 'Buffer' && ArrayIsArray(obj.data)) {
+ return fromArrayLike(obj.data);
+ }
+}
+
+// Static methods
+
+Buffer.isBuffer = function isBuffer(b) {
+ return b instanceof Buffer;
+};
+
+Buffer.compare = function compare(buf1, buf2) {
+ if (!isUint8Array(buf1)) {
+ throw new ERR_INVALID_ARG_TYPE('buf1', ['Buffer', 'Uint8Array'], buf1);
+ }
+
+ if (!isUint8Array(buf2)) {
+ throw new ERR_INVALID_ARG_TYPE('buf2', ['Buffer', 'Uint8Array'], buf2);
+ }
+
+ if (buf1 === buf2) {
+ return 0;
+ }
+
+ return _compare(buf1, buf2);
+};
+
+Buffer.isEncoding = function isEncoding(encoding) {
+ return typeof encoding === 'string' && encoding.length !== 0 &&
+ normalizeEncoding(encoding) !== undefined;
+};
+Buffer[kIsEncodingSymbol] = Buffer.isEncoding;
+
+Buffer.concat = function concat(list, length) {
+ validateArray(list, 'list');
+
+ if (list.length === 0)
+ return new FastBuffer();
+
+ if (length === undefined) {
+ length = 0;
+ for (let i = 0; i < list.length; i++) {
+ if (list[i].length) {
+ length += list[i].length;
+ }
+ }
+ } else {
+ validateOffset(length, 'length');
+ }
+
+ const buffer = Buffer.allocUnsafe(length);
+ let pos = 0;
+ for (let i = 0; i < list.length; i++) {
+ const buf = list[i];
+ if (!isUint8Array(buf)) {
+ // TODO(BridgeAR): This should not be of type ERR_INVALID_ARG_TYPE.
+ // Instead, find the proper error code for this.
+ throw new ERR_INVALID_ARG_TYPE(
+ `list[${i}]`, ['Buffer', 'Uint8Array'], list[i]);
+ }
+ pos += _copyActual(buf, buffer, pos, 0, buf.length);
+ }
+
+ // Note: `length` is always equal to `buffer.length` at this point
+ if (pos < length) {
+ // Zero-fill the remaining bytes if the specified `length` was more than
+ // the actual total length, i.e. if we have some remaining allocated bytes
+ // there were not initialized.
+ TypedArrayPrototypeFill(buffer, 0, pos, length);
+ }
+
+ return buffer;
+};
+
+function base64ByteLength(str, bytes) {
+ // Handle padding
+ if (StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)
+ bytes--;
+ if (bytes > 1 && StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)
+ bytes--;
+
+ // Base64 ratio: 3/4
+ return (bytes * 3) >>> 2;
+}
+
+const encodingOps = {
+ utf8: {
+ encoding: 'utf8',
+ encodingVal: encodingsMap.utf8,
+ byteLength: byteLengthUtf8,
+ write: (buf, string, offset, len) => buf.utf8Write(string, offset, len),
+ slice: (buf, start, end) => buf.utf8Slice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfString(buf, val, byteOffset, encodingsMap.utf8, dir),
+ },
+ ucs2: {
+ encoding: 'ucs2',
+ encodingVal: encodingsMap.utf16le,
+ byteLength: (string) => string.length * 2,
+ write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
+ slice: (buf, start, end) => buf.ucs2Slice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir),
+ },
+ utf16le: {
+ encoding: 'utf16le',
+ encodingVal: encodingsMap.utf16le,
+ byteLength: (string) => string.length * 2,
+ write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
+ slice: (buf, start, end) => buf.ucs2Slice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir),
+ },
+ latin1: {
+ encoding: 'latin1',
+ encodingVal: encodingsMap.latin1,
+ byteLength: (string) => string.length,
+ write: (buf, string, offset, len) => buf.latin1Write(string, offset, len),
+ slice: (buf, start, end) => buf.latin1Slice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfString(buf, val, byteOffset, encodingsMap.latin1, dir),
+ },
+ ascii: {
+ encoding: 'ascii',
+ encodingVal: encodingsMap.ascii,
+ byteLength: (string) => string.length,
+ write: (buf, string, offset, len) => buf.asciiWrite(string, offset, len),
+ slice: (buf, start, end) => buf.asciiSlice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfBuffer(buf,
+ fromStringFast(val, encodingOps.ascii),
+ byteOffset,
+ encodingsMap.ascii,
+ dir),
+ },
+ base64: {
+ encoding: 'base64',
+ encodingVal: encodingsMap.base64,
+ byteLength: (string) => base64ByteLength(string, string.length),
+ write: (buf, string, offset, len) => buf.base64Write(string, offset, len),
+ slice: (buf, start, end) => buf.base64Slice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfBuffer(buf,
+ fromStringFast(val, encodingOps.base64),
+ byteOffset,
+ encodingsMap.base64,
+ dir),
+ },
+ base64url: {
+ encoding: 'base64url',
+ encodingVal: encodingsMap.base64url,
+ byteLength: (string) => base64ByteLength(string, string.length),
+ write: (buf, string, offset, len) =>
+ buf.base64urlWrite(string, offset, len),
+ slice: (buf, start, end) => buf.base64urlSlice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfBuffer(buf,
+ fromStringFast(val, encodingOps.base64url),
+ byteOffset,
+ encodingsMap.base64url,
+ dir),
+ },
+ hex: {
+ encoding: 'hex',
+ encodingVal: encodingsMap.hex,
+ byteLength: (string) => string.length >>> 1,
+ write: (buf, string, offset, len) => buf.hexWrite(string, offset, len),
+ slice: (buf, start, end) => buf.hexSlice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfBuffer(buf,
+ fromStringFast(val, encodingOps.hex),
+ byteOffset,
+ encodingsMap.hex,
+ dir),
+ },
+};
+function getEncodingOps(encoding) {
+ encoding += '';
+ switch (encoding.length) {
+ case 4:
+ if (encoding === 'utf8') return encodingOps.utf8;
+ if (encoding === 'ucs2') return encodingOps.ucs2;
+ encoding = StringPrototypeToLowerCase(encoding);
+ if (encoding === 'utf8') return encodingOps.utf8;
+ if (encoding === 'ucs2') return encodingOps.ucs2;
+ break;
+ case 5:
+ if (encoding === 'utf-8') return encodingOps.utf8;
+ if (encoding === 'ascii') return encodingOps.ascii;
+ if (encoding === 'ucs-2') return encodingOps.ucs2;
+ encoding = StringPrototypeToLowerCase(encoding);
+ if (encoding === 'utf-8') return encodingOps.utf8;
+ if (encoding === 'ascii') return encodingOps.ascii;
+ if (encoding === 'ucs-2') return encodingOps.ucs2;
+ break;
+ case 7:
+ if (encoding === 'utf16le' ||
+ StringPrototypeToLowerCase(encoding) === 'utf16le')
+ return encodingOps.utf16le;
+ break;
+ case 8:
+ if (encoding === 'utf-16le' ||
+ StringPrototypeToLowerCase(encoding) === 'utf-16le')
+ return encodingOps.utf16le;
+ break;
+ case 6:
+ if (encoding === 'latin1' || encoding === 'binary')
+ return encodingOps.latin1;
+ if (encoding === 'base64') return encodingOps.base64;
+ encoding = StringPrototypeToLowerCase(encoding);
+ if (encoding === 'latin1' || encoding === 'binary')
+ return encodingOps.latin1;
+ if (encoding === 'base64') return encodingOps.base64;
+ break;
+ case 3:
+ if (encoding === 'hex' || StringPrototypeToLowerCase(encoding) === 'hex')
+ return encodingOps.hex;
+ break;
+ case 9:
+ if (encoding === 'base64url' ||
+ StringPrototypeToLowerCase(encoding) === 'base64url')
+ return encodingOps.base64url;
+ break;
+ }
+}
+
+function byteLength(string, encoding) {
+ if (typeof string !== 'string') {
+ if (isArrayBufferView(string) || isAnyArrayBuffer(string)) {
+ return string.byteLength;
+ }
+
+ throw new ERR_INVALID_ARG_TYPE(
+ 'string', ['string', 'Buffer', 'ArrayBuffer'], string,
+ );
+ }
+
+ const len = string.length;
+ if (len === 0)
+ return 0;
+
+ if (!encoding || encoding === 'utf8') {
+ return byteLengthUtf8(string);
+ }
+
+ if (encoding === 'ascii') {
+ return len;
+ }
+
+ const ops = getEncodingOps(encoding);
+ if (ops === undefined) {
+ // TODO (ronag): Makes more sense to throw here.
+ // throw new ERR_UNKNOWN_ENCODING(encoding);
+ return byteLengthUtf8(string);
+ }
+
+ return ops.byteLength(string);
+}
+
+Buffer.byteLength = byteLength;
+
+// For backwards compatibility.
+ObjectDefineProperty(Buffer.prototype, 'parent', {
+ __proto__: null,
+ enumerable: true,
+ get() {
+ if (!(this instanceof Buffer))
+ return undefined;
+ return this.buffer;
+ },
+});
+ObjectDefineProperty(Buffer.prototype, 'offset', {
+ __proto__: null,
+ enumerable: true,
+ get() {
+ if (!(this instanceof Buffer))
+ return undefined;
+ return this.byteOffset;
+ },
+});
+
+Buffer.prototype.copy =
+ function copy(target, targetStart, sourceStart, sourceEnd) {
+ return copyImpl(this, target, targetStart, sourceStart, sourceEnd);
+ };
+
+// No need to verify that "buf.length <= MAX_UINT32" since it's a read-only
+// property of a typed array.
+// This behaves neither like String nor Uint8Array in that we set start/end
+// to their upper/lower bounds if the value passed is out of range.
+Buffer.prototype.toString = function toString(encoding, start, end) {
+ if (arguments.length === 0) {
+ return this.utf8Slice(0, this.length);
+ }
+
+ const len = this.length;
+
+ if (start <= 0)
+ start = 0;
+ else if (start >= len)
+ return '';
+ else
+ start = MathTrunc(start) || 0;
+
+ if (end === undefined || end > len)
+ end = len;
+ else
+ end = MathTrunc(end) || 0;
+
+ if (end <= start)
+ return '';
+
+ if (encoding === undefined)
+ return this.utf8Slice(start, end);
+
+ const ops = getEncodingOps(encoding);
+ if (ops === undefined)
+ throw new ERR_UNKNOWN_ENCODING(encoding);
+
+ return ops.slice(this, start, end);
+};
+
+Buffer.prototype.equals = function equals(otherBuffer) {
+ if (!isUint8Array(otherBuffer)) {
+ throw new ERR_INVALID_ARG_TYPE(
+ 'otherBuffer', ['Buffer', 'Uint8Array'], otherBuffer);
+ }
+
+ if (this === otherBuffer)
+ return true;
+ const len = TypedArrayPrototypeGetByteLength(this);
+ if (len !== TypedArrayPrototypeGetByteLength(otherBuffer))
+ return false;
+
+ return len === 0 || _compare(this, otherBuffer) === 0;
+};
+
+let INSPECT_MAX_BYTES = 50;
+// Override how buffers are presented by util.inspect().
+Buffer.prototype[customInspectSymbol] = function inspect(recurseTimes, ctx) {
+ const max = INSPECT_MAX_BYTES;
+ const actualMax = MathMin(max, this.length);
+ const remaining = this.length - max;
+ let str = StringPrototypeTrim(RegExpPrototypeSymbolReplace(
+ /(.{2})/g, this.hexSlice(0, actualMax), '$1 '));
+ if (remaining > 0)
+ str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;
+ // Inspect special properties as well, if possible.
+ if (ctx) {
+ let extras = false;
+ const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
+ const obj = { __proto__: null };
+ ArrayPrototypeForEach(getOwnNonIndexProperties(this, filter),
+ (key) => {
+ extras = true;
+ obj[key] = this[key];
+ });
+ if (extras) {
+ if (this.length !== 0)
+ str += ', ';
+ // '[Object: null prototype] {'.length === 26
+ // This is guarded with a test.
+ str += StringPrototypeSlice(utilInspect(obj, {
+ ...ctx,
+ breakLength: Infinity,
+ compact: true,
+ }), 27, -2);
+ }
+ }
+ let constructorName = 'Buffer';
+ try {
+ const { constructor } = this;
+ if (typeof constructor === 'function' && ObjectPrototypeHasOwnProperty(constructor, 'name')) {
+ constructorName = constructor.name;
+ }
+ } catch { /* Ignore error and use default name */ }
+ return `<${constructorName} ${str}>`;
+};
+Buffer.prototype.inspect = Buffer.prototype[customInspectSymbol];
+
+Buffer.prototype.compare = function compare(target,
+ targetStart,
+ targetEnd,
+ sourceStart,
+ sourceEnd) {
+ if (!isUint8Array(target)) {
+ throw new ERR_INVALID_ARG_TYPE('target', ['Buffer', 'Uint8Array'], target);
+ }
+ if (arguments.length === 1)
+ return _compare(this, target);
+
+ if (targetStart === undefined)
+ targetStart = 0;
+ else
+ validateOffset(targetStart, 'targetStart');
+
+ if (targetEnd === undefined)
+ targetEnd = target.length;
+ else
+ validateOffset(targetEnd, 'targetEnd', 0, target.length);
+
+ if (sourceStart === undefined)
+ sourceStart = 0;
+ else
+ validateOffset(sourceStart, 'sourceStart');
+
+ if (sourceEnd === undefined)
+ sourceEnd = this.length;
+ else
+ validateOffset(sourceEnd, 'sourceEnd', 0, this.length);
+
+ if (sourceStart >= sourceEnd)
+ return (targetStart >= targetEnd ? 0 : -1);
+ if (targetStart >= targetEnd)
+ return 1;
+
+ return compareOffset(this, target, targetStart, sourceStart, targetEnd,
+ sourceEnd);
+};
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant if val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+ validateBuffer(buffer);
+
+ if (typeof byteOffset === 'string') {
+ encoding = byteOffset;
+ byteOffset = undefined;
+ } else if (byteOffset > 0x7fffffff) {
+ byteOffset = 0x7fffffff;
+ } else if (byteOffset < -0x80000000) {
+ byteOffset = -0x80000000;
+ }
+ // Coerce to Number. Values like null and [] become 0.
+ byteOffset = +byteOffset;
+ // If the offset is undefined, "foo", {}, coerces to NaN, search whole buffer.
+ if (NumberIsNaN(byteOffset)) {
+ byteOffset = dir ? 0 : (buffer.length || buffer.byteLength);
+ }
+ dir = !!dir; // Cast to bool.
+
+ if (typeof val === 'number')
+ return indexOfNumber(buffer, val >>> 0, byteOffset, dir);
+
+ let ops;
+ if (encoding === undefined)
+ ops = encodingOps.utf8;
+ else
+ ops = getEncodingOps(encoding);
+
+ if (typeof val === 'string') {
+ if (ops === undefined)
+ throw new ERR_UNKNOWN_ENCODING(encoding);
+ return ops.indexOf(buffer, val, byteOffset, dir);
+ }
+
+ if (isUint8Array(val)) {
+ const encodingVal =
+ (ops === undefined ? encodingsMap.utf8 : ops.encodingVal);
+ return indexOfBuffer(buffer, val, byteOffset, encodingVal, dir);
+ }
+
+ throw new ERR_INVALID_ARG_TYPE(
+ 'value', ['number', 'string', 'Buffer', 'Uint8Array'], val,
+ );
+}
+
+Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+};
+
+Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+};
+
+Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
+ return this.indexOf(val, byteOffset, encoding) !== -1;
+};
+
+// Usage:
+// buffer.fill(number[, offset[, end]])
+// buffer.fill(buffer[, offset[, end]])
+// buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill(value, offset, end, encoding) {
+ return _fill(this, value, offset, end, encoding);
+};
+
+function _fill(buf, value, offset, end, encoding) {
+ if (typeof value === 'string') {
+ if (offset === undefined || typeof offset === 'string') {
+ encoding = offset;
+ offset = 0;
+ end = buf.length;
+ } else if (typeof end === 'string') {
+ encoding = end;
+ end = buf.length;
+ }
+
+ const normalizedEncoding = normalizeEncoding(encoding);
+ if (normalizedEncoding === undefined) {
+ validateString(encoding, 'encoding');
+ throw new ERR_UNKNOWN_ENCODING(encoding);
+ }
+
+ if (value.length === 0) {
+ // If value === '' default to zero.
+ value = 0;
+ } else if (value.length === 1) {
+ // Fast path: If `value` fits into a single byte, use that numeric value.
+ if (normalizedEncoding === 'utf8') {
+ const code = StringPrototypeCharCodeAt(value, 0);
+ if (code < 128) {
+ value = code;
+ }
+ } else if (normalizedEncoding === 'latin1') {
+ value = StringPrototypeCharCodeAt(value, 0);
+ }
+ }
+ } else {
+ encoding = undefined;
+ }
+
+ if (offset === undefined) {
+ offset = 0;
+ end = buf.length;
+ } else {
+ validateOffset(offset, 'offset');
+ // Invalid ranges are not set to a default, so can range check early.
+ if (end === undefined) {
+ end = buf.length;
+ } else {
+ validateOffset(end, 'end', 0, buf.length);
+ }
+ if (offset >= end)
+ return buf;
+ }
+
+
+ if (typeof value === 'number') {
+ // OOB check
+ const byteLen = TypedArrayPrototypeGetByteLength(buf);
+ const fillLength = end - offset;
+ if (offset > end || fillLength + offset > byteLen)
+ throw new ERR_BUFFER_OUT_OF_BOUNDS();
+
+ TypedArrayPrototypeFill(buf, value, offset, end);
+ } else {
+ const res = bindingFill(buf, value, offset, end, encoding);
+ if (res < 0) {
+ if (res === -1)
+ throw new ERR_INVALID_ARG_VALUE('value', value);
+ throw new ERR_BUFFER_OUT_OF_BOUNDS();
+ }
+ }
+
+ return buf;
+}
+
+Buffer.prototype.write = function write(string, offset, length, encoding) {
+ // Buffer#write(string);
+ if (offset === undefined) {
+ return this.utf8Write(string, 0, this.length);
+ }
+ // Buffer#write(string, encoding)
+ if (length === undefined && typeof offset === 'string') {
+ encoding = offset;
+ length = this.length;
+ offset = 0;
+
+ // Buffer#write(string, offset[, length][, encoding])
+ } else {
+ validateOffset(offset, 'offset', 0, this.length);
+
+ const remaining = this.length - offset;
+
+ if (length === undefined) {
+ length = remaining;
+ } else if (typeof length === 'string') {
+ encoding = length;
+ length = remaining;
+ } else {
+ validateOffset(length, 'length', 0, this.length);
+ if (length > remaining)
+ length = remaining;
+ }
+ }
+
+ if (!encoding || encoding === 'utf8')
+ return this.utf8Write(string, offset, length);
+ if (encoding === 'ascii')
+ return this.asciiWrite(string, offset, length);
+
+ const ops = getEncodingOps(encoding);
+ if (ops === undefined)
+ throw new ERR_UNKNOWN_ENCODING(encoding);
+ return ops.write(this, string, offset, length);
+};
+
+Buffer.prototype.toJSON = function toJSON() {
+ if (this.length > 0) {
+ const data = new Array(this.length);
+ for (let i = 0; i < this.length; ++i)
+ data[i] = this[i];
+ return { type: 'Buffer', data };
+ }
+ return { type: 'Buffer', data: [] };
+};
+
+function adjustOffset(offset, length) {
+ // Use Math.trunc() to convert offset to an integer value that can be larger
+ // than an Int32. Hence, don't use offset | 0 or similar techniques.
+ offset = MathTrunc(offset);
+ if (offset === 0) {
+ return 0;
+ }
+ if (offset < 0) {
+ offset += length;
+ return offset > 0 ? offset : 0;
+ }
+ if (offset < length) {
+ return offset;
+ }
+ return NumberIsNaN(offset) ? 0 : length;
+}
+
+Buffer.prototype.subarray = function subarray(start, end) {
+ const srcLength = this.length;
+ start = adjustOffset(start, srcLength);
+ end = end !== undefined ? adjustOffset(end, srcLength) : srcLength;
+ const newLength = end > start ? end - start : 0;
+ return new FastBuffer(this.buffer, this.byteOffset + start, newLength);
+};
+
+Buffer.prototype.slice = function slice(start, end) {
+ return this.subarray(start, end);
+};
+
+function swap(b, n, m) {
+ const i = b[n];
+ b[n] = b[m];
+ b[m] = i;
+}
+
+Buffer.prototype.swap16 = function swap16() {
+ // For Buffer.length < 128, it's generally faster to
+ // do the swap in javascript. For larger buffers,
+ // dropping down to the native code is faster.
+ const len = this.length;
+ if (len % 2 !== 0)
+ throw new ERR_INVALID_BUFFER_SIZE('16-bits');
+ if (len < 128) {
+ for (let i = 0; i < len; i += 2)
+ swap(this, i, i + 1);
+ return this;
+ }
+ return _swap16(this);
+};
+
+Buffer.prototype.swap32 = function swap32() {
+ // For Buffer.length < 192, it's generally faster to
+ // do the swap in javascript. For larger buffers,
+ // dropping down to the native code is faster.
+ const len = this.length;
+ if (len % 4 !== 0)
+ throw new ERR_INVALID_BUFFER_SIZE('32-bits');
+ if (len < 192) {
+ for (let i = 0; i < len; i += 4) {
+ swap(this, i, i + 3);
+ swap(this, i + 1, i + 2);
+ }
+ return this;
+ }
+ return _swap32(this);
+};
+
+Buffer.prototype.swap64 = function swap64() {
+ // For Buffer.length < 192, it's generally faster to
+ // do the swap in javascript. For larger buffers,
+ // dropping down to the native code is faster.
+ const len = this.length;
+ if (len % 8 !== 0)
+ throw new ERR_INVALID_BUFFER_SIZE('64-bits');
+ if (len < 192) {
+ for (let i = 0; i < len; i += 8) {
+ swap(this, i, i + 7);
+ swap(this, i + 1, i + 6);
+ swap(this, i + 2, i + 5);
+ swap(this, i + 3, i + 4);
+ }
+ return this;
+ }
+ return _swap64(this);
+};
+
+Buffer.prototype.toLocaleString = Buffer.prototype.toString;
+
+let transcode;
+if (internalBinding('config').hasIntl) {
+ const {
+ icuErrName,
+ transcode: _transcode,
+ } = internalBinding('icu');
+
+ // Transcodes the Buffer from one encoding to another, returning a new
+ // Buffer instance.
+ transcode = function transcode(source, fromEncoding, toEncoding) {
+ if (!isUint8Array(source)) {
+ throw new ERR_INVALID_ARG_TYPE('source',
+ ['Buffer', 'Uint8Array'], source);
+ }
+ if (source.length === 0) return Buffer.alloc(0);
+
+ fromEncoding = normalizeEncoding(fromEncoding) || fromEncoding;
+ toEncoding = normalizeEncoding(toEncoding) || toEncoding;
+ const result = _transcode(source, fromEncoding, toEncoding);
+ if (typeof result !== 'number')
+ return result;
+
+ const code = icuErrName(result);
+ const err = genericNodeError(
+ `Unable to transcode Buffer [${code}]`,
+ { code: code, errno: result },
+ );
+ throw err;
+ };
+}
+
+function btoa(input) {
+ // The implementation here has not been performance optimized in any way and
+ // should not be.
+ // Refs: https://github.com/nodejs/node/pull/38433#issuecomment-828426932
+ if (arguments.length === 0) {
+ throw new ERR_MISSING_ARGS('input');
+ }
+ const result = _btoa(`${input}`);
+ if (result === -1) {
+ throw lazyDOMException('Invalid character', 'InvalidCharacterError');
+ }
+ return result;
+}
+
+function atob(input) {
+ if (arguments.length === 0) {
+ throw new ERR_MISSING_ARGS('input');
+ }
+
+ const result = _atob(`${input}`);
+
+ switch (result) {
+ case -2: // Invalid character
+ throw lazyDOMException('Invalid character', 'InvalidCharacterError');
+ case -1: // Single character remained
+ throw lazyDOMException(
+ 'The string to be decoded is not correctly encoded.',
+ 'InvalidCharacterError');
+ case -3: // Possible overflow
+ // TODO(@anonrig): Throw correct error in here.
+ throw lazyDOMException('The input causes overflow.', 'InvalidCharacterError');
+ default:
+ return result;
+ }
+}
+
+function isUtf8(input) {
+ if (isTypedArray(input) || isAnyArrayBuffer(input)) {
+ return bindingIsUtf8(input);
+ }
+
+ throw new ERR_INVALID_ARG_TYPE('input', ['ArrayBuffer', 'Buffer', 'TypedArray'], input);
+}
+
+function isAscii(input) {
+ if (isTypedArray(input) || isAnyArrayBuffer(input)) {
+ return bindingIsAscii(input);
+ }
+
+ throw new ERR_INVALID_ARG_TYPE('input', ['ArrayBuffer', 'Buffer', 'TypedArray'], input);
+}
+
+module.exports = {
+ Buffer,
+ SlowBuffer: deprecate(
+ SlowBuffer,
+ 'SlowBuffer() is deprecated. Please use Buffer.allocUnsafeSlow()',
+ 'DEP0030'),
+ transcode,
+ isUtf8,
+ isAscii,
+
+ // Legacy
+ kMaxLength,
+ kStringMaxLength,
+ btoa,
+ atob,
+};
+
+ObjectDefineProperties(module.exports, {
+ constants: {
+ __proto__: null,
+ configurable: false,
+ enumerable: true,
+ value: constants,
+ },
+ INSPECT_MAX_BYTES: {
+ __proto__: null,
+ configurable: true,
+ enumerable: true,
+ get() { return INSPECT_MAX_BYTES; },
+ set(val) {
+ validateNumber(val, 'INSPECT_MAX_BYTES', 0);
+ INSPECT_MAX_BYTES = val;
+ },
+ },
+});
+
+defineLazyProperties(
+ module.exports,
+ 'internal/blob',
+ ['Blob', 'resolveObjectURL'],
+);
+defineLazyProperties(
+ module.exports,
+ 'internal/file',
+ ['File'],
+);
\ No newline at end of file
diff --git a/.idx/node/cluster.js b/.idx/node/cluster.js
new file mode 100644
index 0000000..6f3dc16
--- /dev/null
+++ b/.idx/node/cluster.js
@@ -0,0 +1,8 @@
+'use strict';
+
+const {
+ ObjectPrototypeHasOwnProperty: ObjectHasOwn,
+} = primordials;
+
+const childOrPrimary = ObjectHasOwn(process.env, 'NODE_UNIQUE_ID') ? 'child' : 'primary';
+module.exports = require(`internal/cluster/${childOrPrimary}`);
\ No newline at end of file
diff --git a/.idx/node/crypto.js b/.idx/node/crypto.js
new file mode 100644
index 0000000..06bfebc
--- /dev/null
+++ b/.idx/node/crypto.js
@@ -0,0 +1,1365 @@
+'use strict';
+
+const {
+ Array,
+ ArrayBufferIsView,
+ ArrayIsArray,
+ ArrayPrototypeForEach,
+ MathFloor,
+ MathMin,
+ MathTrunc,
+ NumberIsInteger,
+ NumberIsNaN,
+ NumberMAX_SAFE_INTEGER,
+ NumberMIN_SAFE_INTEGER,
+ ObjectDefineProperties,
+ ObjectDefineProperty,
+ ObjectPrototypeHasOwnProperty,
+ ObjectSetPrototypeOf,
+ RegExpPrototypeSymbolReplace,
+ StringPrototypeCharCodeAt,
+ StringPrototypeSlice,
+ StringPrototypeToLowerCase,
+ StringPrototypeTrim,
+ SymbolSpecies,
+ SymbolToPrimitive,
+ TypedArrayPrototypeFill,
+ TypedArrayPrototypeGetBuffer,
+ TypedArrayPrototypeGetByteLength,
+ TypedArrayPrototypeGetByteOffset,
+ TypedArrayPrototypeGetLength,
+ TypedArrayPrototypeSet,
+ TypedArrayPrototypeSlice,
+ Uint8Array,
+ Uint8ArrayPrototype,
+} = primordials;
+
+const {
+ byteLengthUtf8,
+ compare: _compare,
+ compareOffset,
+ copy: _copy,
+ fill: bindingFill,
+ isAscii: bindingIsAscii,
+ isUtf8: bindingIsUtf8,
+ indexOfBuffer,
+ indexOfNumber,
+ indexOfString,
+ swap16: _swap16,
+ swap32: _swap32,
+ swap64: _swap64,
+ kMaxLength,
+ kStringMaxLength,
+ atob: _atob,
+ btoa: _btoa,
+} = internalBinding('buffer');
+const {
+ constants: {
+ ALL_PROPERTIES,
+ ONLY_ENUMERABLE,
+ },
+ getOwnNonIndexProperties,
+ isInsideNodeModules,
+} = internalBinding('util');
+const {
+ customInspectSymbol,
+ lazyDOMException,
+ normalizeEncoding,
+ kIsEncodingSymbol,
+ defineLazyProperties,
+ encodingsMap,
+ deprecate,
+} = require('internal/util');
+const {
+ isAnyArrayBuffer,
+ isArrayBufferView,
+ isUint8Array,
+ isTypedArray,
+} = require('internal/util/types');
+const {
+ inspect: utilInspect,
+} = require('internal/util/inspect');
+
+const {
+ codes: {
+ ERR_BUFFER_OUT_OF_BOUNDS,
+ ERR_INVALID_ARG_TYPE,
+ ERR_INVALID_ARG_VALUE,
+ ERR_INVALID_BUFFER_SIZE,
+ ERR_MISSING_ARGS,
+ ERR_OUT_OF_RANGE,
+ ERR_UNKNOWN_ENCODING,
+ },
+ genericNodeError,
+} = require('internal/errors');
+const {
+ validateArray,
+ validateBuffer,
+ validateInteger,
+ validateNumber,
+ validateString,
+} = require('internal/validators');
+// Provide validateInteger() but with kMaxLength as the default maximum value.
+const validateOffset = (value, name, min = 0, max = kMaxLength) =>
+ validateInteger(value, name, min, max);
+
+const {
+ FastBuffer,
+ markAsUntransferable,
+ addBufferPrototypeMethods,
+ createUnsafeBuffer,
+} = require('internal/buffer');
+
+FastBuffer.prototype.constructor = Buffer;
+Buffer.prototype = FastBuffer.prototype;
+addBufferPrototypeMethods(Buffer.prototype);
+
+const constants = ObjectDefineProperties({}, {
+ MAX_LENGTH: {
+ __proto__: null,
+ value: kMaxLength,
+ writable: false,
+ enumerable: true,
+ },
+ MAX_STRING_LENGTH: {
+ __proto__: null,
+ value: kStringMaxLength,
+ writable: false,
+ enumerable: true,
+ },
+});
+
+Buffer.poolSize = 8 * 1024;
+let poolSize, poolOffset, allocPool, allocBuffer;
+
+function createPool() {
+ poolSize = Buffer.poolSize;
+ allocBuffer = createUnsafeBuffer(poolSize);
+ allocPool = allocBuffer.buffer;
+ markAsUntransferable(allocPool);
+ poolOffset = 0;
+}
+createPool();
+
+function alignPool() {
+ // Ensure aligned slices
+ if (poolOffset & 0x7) {
+ poolOffset |= 0x7;
+ poolOffset++;
+ }
+}
+
+let bufferWarningAlreadyEmitted = false;
+let nodeModulesCheckCounter = 0;
+const bufferWarning = 'Buffer() is deprecated due to security and usability ' +
+ 'issues. Please use the Buffer.alloc(), ' +
+ 'Buffer.allocUnsafe(), or Buffer.from() methods instead.';
+
+function showFlaggedDeprecation() {
+ if (bufferWarningAlreadyEmitted ||
+ ++nodeModulesCheckCounter > 10000 ||
+ (!require('internal/options').getOptionValue('--pending-deprecation') &&
+ isInsideNodeModules(100, true))) {
+ // We don't emit a warning, because we either:
+ // - Already did so, or
+ // - Already checked too many times whether a call is coming
+ // from node_modules and want to stop slowing down things, or
+ // - We aren't running with `--pending-deprecation` enabled,
+ // and the code is inside `node_modules`.
+ // - We found node_modules in up to the topmost 100 frames, or
+ // there are more than 100 frames and we don't want to search anymore.
+ return;
+ }
+
+ process.emitWarning(bufferWarning, 'DeprecationWarning', 'DEP0005');
+ bufferWarningAlreadyEmitted = true;
+}
+
+function toInteger(n, defaultVal) {
+ n = +n;
+ if (!NumberIsNaN(n) &&
+ n >= NumberMIN_SAFE_INTEGER &&
+ n <= NumberMAX_SAFE_INTEGER) {
+ return ((n % 1) === 0 ? n : MathFloor(n));
+ }
+ return defaultVal;
+}
+
+function copyImpl(source, target, targetStart, sourceStart, sourceEnd) {
+ if (!ArrayBufferIsView(source))
+ throw new ERR_INVALID_ARG_TYPE('source', ['Buffer', 'Uint8Array'], source);
+ if (!ArrayBufferIsView(target))
+ throw new ERR_INVALID_ARG_TYPE('target', ['Buffer', 'Uint8Array'], target);
+
+ if (targetStart === undefined) {
+ targetStart = 0;
+ } else {
+ targetStart = NumberIsInteger(targetStart) ? targetStart : toInteger(targetStart, 0);
+ if (targetStart < 0)
+ throw new ERR_OUT_OF_RANGE('targetStart', '>= 0', targetStart);
+ }
+
+ if (sourceStart === undefined) {
+ sourceStart = 0;
+ } else {
+ sourceStart = NumberIsInteger(sourceStart) ? sourceStart : toInteger(sourceStart, 0);
+ if (sourceStart < 0 || sourceStart > source.byteLength)
+ throw new ERR_OUT_OF_RANGE('sourceStart', `>= 0 && <= ${source.byteLength}`, sourceStart);
+ }
+
+ if (sourceEnd === undefined) {
+ sourceEnd = source.byteLength;
+ } else {
+ sourceEnd = NumberIsInteger(sourceEnd) ? sourceEnd : toInteger(sourceEnd, 0);
+ if (sourceEnd < 0)
+ throw new ERR_OUT_OF_RANGE('sourceEnd', '>= 0', sourceEnd);
+ }
+
+ if (targetStart >= target.byteLength || sourceStart >= sourceEnd)
+ return 0;
+
+ return _copyActual(source, target, targetStart, sourceStart, sourceEnd);
+}
+
+function _copyActual(source, target, targetStart, sourceStart, sourceEnd) {
+ if (sourceEnd - sourceStart > target.byteLength - targetStart)
+ sourceEnd = sourceStart + target.byteLength - targetStart;
+
+ let nb = sourceEnd - sourceStart;
+ const sourceLen = source.byteLength - sourceStart;
+ if (nb > sourceLen)
+ nb = sourceLen;
+
+ if (nb <= 0)
+ return 0;
+
+ _copy(source, target, targetStart, sourceStart, nb);
+
+ return nb;
+}
+
+/**
+ * The Buffer() constructor is deprecated in documentation and should not be
+ * used moving forward. Rather, developers should use one of the three new
+ * factory APIs: Buffer.from(), Buffer.allocUnsafe() or Buffer.alloc() based on
+ * their specific needs. There is no runtime deprecation because of the extent
+ * to which the Buffer constructor is used in the ecosystem currently -- a
+ * runtime deprecation would introduce too much breakage at this time. It's not
+ * likely that the Buffer constructors would ever actually be removed.
+ * Deprecation Code: DEP0005
+ * @returns {Buffer}
+ */
+function Buffer(arg, encodingOrOffset, length) {
+ showFlaggedDeprecation();
+ // Common case.
+ if (typeof arg === 'number') {
+ if (typeof encodingOrOffset === 'string') {
+ throw new ERR_INVALID_ARG_TYPE('string', 'string', arg);
+ }
+ return Buffer.alloc(arg);
+ }
+ return Buffer.from(arg, encodingOrOffset, length);
+}
+
+ObjectDefineProperty(Buffer, SymbolSpecies, {
+ __proto__: null,
+ enumerable: false,
+ configurable: true,
+ get() { return FastBuffer; },
+});
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ * @param {any} value
+ * @param {BufferEncoding|number} encodingOrOffset
+ * @param {number} [length]
+ * @returns {Buffer}
+ */
+Buffer.from = function from(value, encodingOrOffset, length) {
+ if (typeof value === 'string')
+ return fromString(value, encodingOrOffset);
+
+ if (typeof value === 'object' && value !== null) {
+ if (isAnyArrayBuffer(value))
+ return fromArrayBuffer(value, encodingOrOffset, length);
+
+ const valueOf = value.valueOf && value.valueOf();
+ if (valueOf != null &&
+ valueOf !== value &&
+ (typeof valueOf === 'string' || typeof valueOf === 'object')) {
+ return from(valueOf, encodingOrOffset, length);
+ }
+
+ const b = fromObject(value);
+ if (b)
+ return b;
+
+ if (typeof value[SymbolToPrimitive] === 'function') {
+ const primitive = value[SymbolToPrimitive]('string');
+ if (typeof primitive === 'string') {
+ return fromString(primitive, encodingOrOffset);
+ }
+ }
+ }
+
+ throw new ERR_INVALID_ARG_TYPE(
+ 'first argument',
+ ['string', 'Buffer', 'ArrayBuffer', 'Array', 'Array-like Object'],
+ value,
+ );
+};
+
+/**
+ * Creates the Buffer as a copy of the underlying ArrayBuffer of the view
+ * rather than the contents of the view.
+ * @param {TypedArray} view
+ * @param {number} [offset]
+ * @param {number} [length]
+ * @returns {Buffer}
+ */
+Buffer.copyBytesFrom = function copyBytesFrom(view, offset, length) {
+ if (!isTypedArray(view)) {
+ throw new ERR_INVALID_ARG_TYPE('view', [ 'TypedArray' ], view);
+ }
+
+ const viewLength = TypedArrayPrototypeGetLength(view);
+ if (viewLength === 0) {
+ return Buffer.alloc(0);
+ }
+
+ if (offset !== undefined || length !== undefined) {
+ if (offset !== undefined) {
+ validateInteger(offset, 'offset', 0);
+ if (offset >= viewLength) return Buffer.alloc(0);
+ } else {
+ offset = 0;
+ }
+ let end;
+ if (length !== undefined) {
+ validateInteger(length, 'length', 0);
+ end = offset + length;
+ } else {
+ end = viewLength;
+ }
+
+ view = TypedArrayPrototypeSlice(view, offset, end);
+ }
+
+ return fromArrayLike(new Uint8Array(
+ TypedArrayPrototypeGetBuffer(view),
+ TypedArrayPrototypeGetByteOffset(view),
+ TypedArrayPrototypeGetByteLength(view)));
+};
+
+// Identical to the built-in %TypedArray%.of(), but avoids using the deprecated
+// Buffer() constructor. Must use arrow function syntax to avoid automatically
+// adding a `prototype` property and making the function a constructor.
+//
+// Refs: https://tc39.github.io/ecma262/#sec-%typedarray%.of
+// Refs: https://esdiscuss.org/topic/isconstructor#content-11
+const of = (...items) => {
+ const newObj = createUnsafeBuffer(items.length);
+ for (let k = 0; k < items.length; k++)
+ newObj[k] = items[k];
+ return newObj;
+};
+Buffer.of = of;
+
+ObjectSetPrototypeOf(Buffer, Uint8Array);
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ * @returns {FastBuffer}
+ */
+Buffer.alloc = function alloc(size, fill, encoding) {
+ validateNumber(size, 'size', 0, kMaxLength);
+ if (fill !== undefined && fill !== 0 && size > 0) {
+ const buf = createUnsafeBuffer(size);
+ return _fill(buf, fill, 0, buf.length, encoding);
+ }
+ return new FastBuffer(size);
+};
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer
+ * instance. If `--zero-fill-buffers` is set, will zero-fill the buffer.
+ * @returns {FastBuffer}
+ */
+Buffer.allocUnsafe = function allocUnsafe(size) {
+ validateNumber(size, 'size', 0, kMaxLength);
+ return allocate(size);
+};
+
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled
+ * Buffer instance that is not allocated off the pre-initialized pool.
+ * If `--zero-fill-buffers` is set, will zero-fill the buffer.
+ * @param {number} size
+ * @returns {FastBuffer|undefined}
+ */
+Buffer.allocUnsafeSlow = function allocUnsafeSlow(size) {
+ validateNumber(size, 'size', 0, kMaxLength);
+ return createUnsafeBuffer(size);
+};
+
+// If --zero-fill-buffers command line argument is set, a zero-filled
+// buffer is returned.
+function SlowBuffer(size) {
+ validateNumber(size, 'size', 0, kMaxLength);
+ return createUnsafeBuffer(size);
+}
+
+ObjectSetPrototypeOf(SlowBuffer.prototype, Uint8ArrayPrototype);
+ObjectSetPrototypeOf(SlowBuffer, Uint8Array);
+
+function allocate(size) {
+ if (size <= 0) {
+ return new FastBuffer();
+ }
+ if (size < (Buffer.poolSize >>> 1)) {
+ if (size > (poolSize - poolOffset))
+ createPool();
+ const b = new FastBuffer(allocPool, poolOffset, size);
+ poolOffset += size;
+ alignPool();
+ return b;
+ }
+ return createUnsafeBuffer(size);
+}
+
+function fromStringFast(string, ops) {
+ const maxLength = Buffer.poolSize >>> 1;
+
+ let length = string.length; // Min length
+
+ if (length >= maxLength)
+ return createFromString(string, ops);
+
+ length *= 4; // Max length (4 bytes per character)
+
+ if (length >= maxLength)
+ length = ops.byteLength(string); // Actual length
+
+ if (length >= maxLength)
+ return createFromString(string, ops, length);
+
+ if (length > (poolSize - poolOffset))
+ createPool();
+
+ const actual = ops.write(allocBuffer, string, poolOffset, length);
+ const b = new FastBuffer(allocPool, poolOffset, actual);
+
+ poolOffset += actual;
+ alignPool();
+ return b;
+}
+
+function createFromString(string, ops, length = ops.byteLength(string)) {
+ const buf = Buffer.allocUnsafeSlow(length);
+ const actual = ops.write(buf, string, 0, length);
+ return actual < length ? new FastBuffer(buf.buffer, 0, actual) : buf;
+}
+
+function fromString(string, encoding) {
+ let ops;
+ if (!encoding || encoding === 'utf8' || typeof encoding !== 'string') {
+ ops = encodingOps.utf8;
+ } else {
+ ops = getEncodingOps(encoding);
+ if (ops === undefined)
+ throw new ERR_UNKNOWN_ENCODING(encoding);
+ }
+
+ return string.length === 0 ? new FastBuffer() : fromStringFast(string, ops);
+}
+
+function fromArrayBuffer(obj, byteOffset, length) {
+ // Convert byteOffset to integer
+ if (byteOffset === undefined) {
+ byteOffset = 0;
+ } else {
+ byteOffset = +byteOffset;
+ if (NumberIsNaN(byteOffset))
+ byteOffset = 0;
+ }
+
+ const maxLength = obj.byteLength - byteOffset;
+
+ if (maxLength < 0)
+ throw new ERR_BUFFER_OUT_OF_BOUNDS('offset');
+
+ if (length !== undefined) {
+ // Convert length to non-negative integer.
+ length = +length;
+ if (length > 0) {
+ if (length > maxLength)
+ throw new ERR_BUFFER_OUT_OF_BOUNDS('length');
+ } else {
+ length = 0;
+ }
+ }
+
+ return new FastBuffer(obj, byteOffset, length);
+}
+
+function fromArrayLike(obj) {
+ if (obj.length <= 0)
+ return new FastBuffer();
+ if (obj.length < (Buffer.poolSize >>> 1)) {
+ if (obj.length > (poolSize - poolOffset))
+ createPool();
+ const b = new FastBuffer(allocPool, poolOffset, obj.length);
+ TypedArrayPrototypeSet(b, obj, 0);
+ poolOffset += obj.length;
+ alignPool();
+ return b;
+ }
+ return new FastBuffer(obj);
+}
+
+function fromObject(obj) {
+ if (obj.length !== undefined || isAnyArrayBuffer(obj.buffer)) {
+ if (typeof obj.length !== 'number') {
+ return new FastBuffer();
+ }
+ return fromArrayLike(obj);
+ }
+
+ if (obj.type === 'Buffer' && ArrayIsArray(obj.data)) {
+ return fromArrayLike(obj.data);
+ }
+}
+
+// Static methods
+
+Buffer.isBuffer = function isBuffer(b) {
+ return b instanceof Buffer;
+};
+
+Buffer.compare = function compare(buf1, buf2) {
+ if (!isUint8Array(buf1)) {
+ throw new ERR_INVALID_ARG_TYPE('buf1', ['Buffer', 'Uint8Array'], buf1);
+ }
+
+ if (!isUint8Array(buf2)) {
+ throw new ERR_INVALID_ARG_TYPE('buf2', ['Buffer', 'Uint8Array'], buf2);
+ }
+
+ if (buf1 === buf2) {
+ return 0;
+ }
+
+ return _compare(buf1, buf2);
+};
+
+Buffer.isEncoding = function isEncoding(encoding) {
+ return typeof encoding === 'string' && encoding.length !== 0 &&
+ normalizeEncoding(encoding) !== undefined;
+};
+Buffer[kIsEncodingSymbol] = Buffer.isEncoding;
+
+Buffer.concat = function concat(list, length) {
+ validateArray(list, 'list');
+
+ if (list.length === 0)
+ return new FastBuffer();
+
+ if (length === undefined) {
+ length = 0;
+ for (let i = 0; i < list.length; i++) {
+ if (list[i].length) {
+ length += list[i].length;
+ }
+ }
+ } else {
+ validateOffset(length, 'length');
+ }
+
+ const buffer = Buffer.allocUnsafe(length);
+ let pos = 0;
+ for (let i = 0; i < list.length; i++) {
+ const buf = list[i];
+ if (!isUint8Array(buf)) {
+ // TODO(BridgeAR): This should not be of type ERR_INVALID_ARG_TYPE.
+ // Instead, find the proper error code for this.
+ throw new ERR_INVALID_ARG_TYPE(
+ `list[${i}]`, ['Buffer', 'Uint8Array'], list[i]);
+ }
+ pos += _copyActual(buf, buffer, pos, 0, buf.length);
+ }
+
+ // Note: `length` is always equal to `buffer.length` at this point
+ if (pos < length) {
+ // Zero-fill the remaining bytes if the specified `length` was more than
+ // the actual total length, i.e. if we have some remaining allocated bytes
+ // there were not initialized.
+ TypedArrayPrototypeFill(buffer, 0, pos, length);
+ }
+
+ return buffer;
+};
+
+function base64ByteLength(str, bytes) {
+ // Handle padding
+ if (StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)
+ bytes--;
+ if (bytes > 1 && StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)
+ bytes--;
+
+ // Base64 ratio: 3/4
+ return (bytes * 3) >>> 2;
+}
+
+const encodingOps = {
+ utf8: {
+ encoding: 'utf8',
+ encodingVal: encodingsMap.utf8,
+ byteLength: byteLengthUtf8,
+ write: (buf, string, offset, len) => buf.utf8Write(string, offset, len),
+ slice: (buf, start, end) => buf.utf8Slice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfString(buf, val, byteOffset, encodingsMap.utf8, dir),
+ },
+ ucs2: {
+ encoding: 'ucs2',
+ encodingVal: encodingsMap.utf16le,
+ byteLength: (string) => string.length * 2,
+ write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
+ slice: (buf, start, end) => buf.ucs2Slice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir),
+ },
+ utf16le: {
+ encoding: 'utf16le',
+ encodingVal: encodingsMap.utf16le,
+ byteLength: (string) => string.length * 2,
+ write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
+ slice: (buf, start, end) => buf.ucs2Slice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir),
+ },
+ latin1: {
+ encoding: 'latin1',
+ encodingVal: encodingsMap.latin1,
+ byteLength: (string) => string.length,
+ write: (buf, string, offset, len) => buf.latin1Write(string, offset, len),
+ slice: (buf, start, end) => buf.latin1Slice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfString(buf, val, byteOffset, encodingsMap.latin1, dir),
+ },
+ ascii: {
+ encoding: 'ascii',
+ encodingVal: encodingsMap.ascii,
+ byteLength: (string) => string.length,
+ write: (buf, string, offset, len) => buf.asciiWrite(string, offset, len),
+ slice: (buf, start, end) => buf.asciiSlice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfBuffer(buf,
+ fromStringFast(val, encodingOps.ascii),
+ byteOffset,
+ encodingsMap.ascii,
+ dir),
+ },
+ base64: {
+ encoding: 'base64',
+ encodingVal: encodingsMap.base64,
+ byteLength: (string) => base64ByteLength(string, string.length),
+ write: (buf, string, offset, len) => buf.base64Write(string, offset, len),
+ slice: (buf, start, end) => buf.base64Slice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfBuffer(buf,
+ fromStringFast(val, encodingOps.base64),
+ byteOffset,
+ encodingsMap.base64,
+ dir),
+ },
+ base64url: {
+ encoding: 'base64url',
+ encodingVal: encodingsMap.base64url,
+ byteLength: (string) => base64ByteLength(string, string.length),
+ write: (buf, string, offset, len) =>
+ buf.base64urlWrite(string, offset, len),
+ slice: (buf, start, end) => buf.base64urlSlice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfBuffer(buf,
+ fromStringFast(val, encodingOps.base64url),
+ byteOffset,
+ encodingsMap.base64url,
+ dir),
+ },
+ hex: {
+ encoding: 'hex',
+ encodingVal: encodingsMap.hex,
+ byteLength: (string) => string.length >>> 1,
+ write: (buf, string, offset, len) => buf.hexWrite(string, offset, len),
+ slice: (buf, start, end) => buf.hexSlice(start, end),
+ indexOf: (buf, val, byteOffset, dir) =>
+ indexOfBuffer(buf,
+ fromStringFast(val, encodingOps.hex),
+ byteOffset,
+ encodingsMap.hex,
+ dir),
+ },
+};
+function getEncodingOps(encoding) {
+ encoding += '';
+ switch (encoding.length) {
+ case 4:
+ if (encoding === 'utf8') return encodingOps.utf8;
+ if (encoding === 'ucs2') return encodingOps.ucs2;
+ encoding = StringPrototypeToLowerCase(encoding);
+ if (encoding === 'utf8') return encodingOps.utf8;
+ if (encoding === 'ucs2') return encodingOps.ucs2;
+ break;
+ case 5:
+ if (encoding === 'utf-8') return encodingOps.utf8;
+ if (encoding === 'ascii') return encodingOps.ascii;
+ if (encoding === 'ucs-2') return encodingOps.ucs2;
+ encoding = StringPrototypeToLowerCase(encoding);
+ if (encoding === 'utf-8') return encodingOps.utf8;
+ if (encoding === 'ascii') return encodingOps.ascii;
+ if (encoding === 'ucs-2') return encodingOps.ucs2;
+ break;
+ case 7:
+ if (encoding === 'utf16le' ||
+ StringPrototypeToLowerCase(encoding) === 'utf16le')
+ return encodingOps.utf16le;
+ break;
+ case 8:
+ if (encoding === 'utf-16le' ||
+ StringPrototypeToLowerCase(encoding) === 'utf-16le')
+ return encodingOps.utf16le;
+ break;
+ case 6:
+ if (encoding === 'latin1' || encoding === 'binary')
+ return encodingOps.latin1;
+ if (encoding === 'base64') return encodingOps.base64;
+ encoding = StringPrototypeToLowerCase(encoding);
+ if (encoding === 'latin1' || encoding === 'binary')
+ return encodingOps.latin1;
+ if (encoding === 'base64') return encodingOps.base64;
+ break;
+ case 3:
+ if (encoding === 'hex' || StringPrototypeToLowerCase(encoding) === 'hex')
+ return encodingOps.hex;
+ break;
+ case 9:
+ if (encoding === 'base64url' ||
+ StringPrototypeToLowerCase(encoding) === 'base64url')
+ return encodingOps.base64url;
+ break;
+ }
+}
+
+function byteLength(string, encoding) {
+ if (typeof string !== 'string') {
+ if (isArrayBufferView(string) || isAnyArrayBuffer(string)) {
+ return string.byteLength;
+ }
+
+ throw new ERR_INVALID_ARG_TYPE(
+ 'string', ['string', 'Buffer', 'ArrayBuffer'], string,
+ );
+ }
+
+ const len = string.length;
+ if (len === 0)
+ return 0;
+
+ if (!encoding || encoding === 'utf8') {
+ return byteLengthUtf8(string);
+ }
+
+ if (encoding === 'ascii') {
+ return len;
+ }
+
+ const ops = getEncodingOps(encoding);
+ if (ops === undefined) {
+ // TODO (ronag): Makes more sense to throw here.
+ // throw new ERR_UNKNOWN_ENCODING(encoding);
+ return byteLengthUtf8(string);
+ }
+
+ return ops.byteLength(string);
+}
+
+Buffer.byteLength = byteLength;
+
+// For backwards compatibility.
+ObjectDefineProperty(Buffer.prototype, 'parent', {
+ __proto__: null,
+ enumerable: true,
+ get() {
+ if (!(this instanceof Buffer))
+ return undefined;
+ return this.buffer;
+ },
+});
+ObjectDefineProperty(Buffer.prototype, 'offset', {
+ __proto__: null,
+ enumerable: true,
+ get() {
+ if (!(this instanceof Buffer))
+ return undefined;
+ return this.byteOffset;
+ },
+});
+
+Buffer.prototype.copy =
+ function copy(target, targetStart, sourceStart, sourceEnd) {
+ return copyImpl(this, target, targetStart, sourceStart, sourceEnd);
+ };
+
+// No need to verify that "buf.length <= MAX_UINT32" since it's a read-only
+// property of a typed array.
+// This behaves neither like String nor Uint8Array in that we set start/end
+// to their upper/lower bounds if the value passed is out of range.
+Buffer.prototype.toString = function toString(encoding, start, end) {
+ if (arguments.length === 0) {
+ return this.utf8Slice(0, this.length);
+ }
+
+ const len = this.length;
+
+ if (start <= 0)
+ start = 0;
+ else if (start >= len)
+ return '';
+ else
+ start = MathTrunc(start) || 0;
+
+ if (end === undefined || end > len)
+ end = len;
+ else
+ end = MathTrunc(end) || 0;
+
+ if (end <= start)
+ return '';
+
+ if (encoding === undefined)
+ return this.utf8Slice(start, end);
+
+ const ops = getEncodingOps(encoding);
+ if (ops === undefined)
+ throw new ERR_UNKNOWN_ENCODING(encoding);
+
+ return ops.slice(this, start, end);
+};
+
+Buffer.prototype.equals = function equals(otherBuffer) {
+ if (!isUint8Array(otherBuffer)) {
+ throw new ERR_INVALID_ARG_TYPE(
+ 'otherBuffer', ['Buffer', 'Uint8Array'], otherBuffer);
+ }
+
+ if (this === otherBuffer)
+ return true;
+ const len = TypedArrayPrototypeGetByteLength(this);
+ if (len !== TypedArrayPrototypeGetByteLength(otherBuffer))
+ return false;
+
+ return len === 0 || _compare(this, otherBuffer) === 0;
+};
+
+let INSPECT_MAX_BYTES = 50;
+// Override how buffers are presented by util.inspect().
+Buffer.prototype[customInspectSymbol] = function inspect(recurseTimes, ctx) {
+ const max = INSPECT_MAX_BYTES;
+ const actualMax = MathMin(max, this.length);
+ const remaining = this.length - max;
+ let str = StringPrototypeTrim(RegExpPrototypeSymbolReplace(
+ /(.{2})/g, this.hexSlice(0, actualMax), '$1 '));
+ if (remaining > 0)
+ str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;
+ // Inspect special properties as well, if possible.
+ if (ctx) {
+ let extras = false;
+ const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
+ const obj = { __proto__: null };
+ ArrayPrototypeForEach(getOwnNonIndexProperties(this, filter),
+ (key) => {
+ extras = true;
+ obj[key] = this[key];
+ });
+ if (extras) {
+ if (this.length !== 0)
+ str += ', ';
+ // '[Object: null prototype] {'.length === 26
+ // This is guarded with a test.
+ str += StringPrototypeSlice(utilInspect(obj, {
+ ...ctx,
+ breakLength: Infinity,
+ compact: true,
+ }), 27, -2);
+ }
+ }
+ let constructorName = 'Buffer';
+ try {
+ const { constructor } = this;
+ if (typeof constructor === 'function' && ObjectPrototypeHasOwnProperty(constructor, 'name')) {
+ constructorName = constructor.name;
+ }
+ } catch { /* Ignore error and use default name */ }
+ return `<${constructorName} ${str}>`;
+};
+Buffer.prototype.inspect = Buffer.prototype[customInspectSymbol];
+
+Buffer.prototype.compare = function compare(target,
+ targetStart,
+ targetEnd,
+ sourceStart,
+ sourceEnd) {
+ if (!isUint8Array(target)) {
+ throw new ERR_INVALID_ARG_TYPE('target', ['Buffer', 'Uint8Array'], target);
+ }
+ if (arguments.length === 1)
+ return _compare(this, target);
+
+ if (targetStart === undefined)
+ targetStart = 0;
+ else
+ validateOffset(targetStart, 'targetStart');
+
+ if (targetEnd === undefined)
+ targetEnd = target.length;
+ else
+ validateOffset(targetEnd, 'targetEnd', 0, target.length);
+
+ if (sourceStart === undefined)
+ sourceStart = 0;
+ else
+ validateOffset(sourceStart, 'sourceStart');
+
+ if (sourceEnd === undefined)
+ sourceEnd = this.length;
+ else
+ validateOffset(sourceEnd, 'sourceEnd', 0, this.length);
+
+ if (sourceStart >= sourceEnd)
+ return (targetStart >= targetEnd ? 0 : -1);
+ if (targetStart >= targetEnd)
+ return 1;
+
+ return compareOffset(this, target, targetStart, sourceStart, targetEnd,
+ sourceEnd);
+};
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant if val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+ validateBuffer(buffer);
+
+ if (typeof byteOffset === 'string') {
+ encoding = byteOffset;
+ byteOffset = undefined;
+ } else if (byteOffset > 0x7fffffff) {
+ byteOffset = 0x7fffffff;
+ } else if (byteOffset < -0x80000000) {
+ byteOffset = -0x80000000;
+ }
+ // Coerce to Number. Values like null and [] become 0.
+ byteOffset = +byteOffset;
+ // If the offset is undefined, "foo", {}, coerces to NaN, search whole buffer.
+ if (NumberIsNaN(byteOffset)) {
+ byteOffset = dir ? 0 : (buffer.length || buffer.byteLength);
+ }
+ dir = !!dir; // Cast to bool.
+
+ if (typeof val === 'number')
+ return indexOfNumber(buffer, val >>> 0, byteOffset, dir);
+
+ let ops;
+ if (encoding === undefined)
+ ops = encodingOps.utf8;
+ else
+ ops = getEncodingOps(encoding);
+
+ if (typeof val === 'string') {
+ if (ops === undefined)
+ throw new ERR_UNKNOWN_ENCODING(encoding);
+ return ops.indexOf(buffer, val, byteOffset, dir);
+ }
+
+ if (isUint8Array(val)) {
+ const encodingVal =
+ (ops === undefined ? encodingsMap.utf8 : ops.encodingVal);
+ return indexOfBuffer(buffer, val, byteOffset, encodingVal, dir);
+ }
+
+ throw new ERR_INVALID_ARG_TYPE(
+ 'value', ['number', 'string', 'Buffer', 'Uint8Array'], val,
+ );
+}
+
+Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+};
+
+Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+};
+
+Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
+ return this.indexOf(val, byteOffset, encoding) !== -1;
+};
+
+// Usage:
+// buffer.fill(number[, offset[, end]])
+// buffer.fill(buffer[, offset[, end]])
+// buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill(value, offset, end, encoding) {
+ return _fill(this, value, offset, end, encoding);
+};
+
+function _fill(buf, value, offset, end, encoding) {
+ if (typeof value === 'string') {
+ if (offset === undefined || typeof offset === 'string') {
+ encoding = offset;
+ offset = 0;
+ end = buf.length;
+ } else if (typeof end === 'string') {
+ encoding = end;
+ end = buf.length;
+ }
+
+ const normalizedEncoding = normalizeEncoding(encoding);
+ if (normalizedEncoding === undefined) {
+ validateString(encoding, 'encoding');
+ throw new ERR_UNKNOWN_ENCODING(encoding);
+ }
+
+ if (value.length === 0) {
+ // If value === '' default to zero.
+ value = 0;
+ } else if (value.length === 1) {
+ // Fast path: If `value` fits into a single byte, use that numeric value.
+ if (normalizedEncoding === 'utf8') {
+ const code = StringPrototypeCharCodeAt(value, 0);
+ if (code < 128) {
+ value = code;
+ }
+ } else if (normalizedEncoding === 'latin1') {
+ value = StringPrototypeCharCodeAt(value, 0);
+ }
+ }
+ } else {
+ encoding = undefined;
+ }
+
+ if (offset === undefined) {
+ offset = 0;
+ end = buf.length;
+ } else {
+ validateOffset(offset, 'offset');
+ // Invalid ranges are not set to a default, so can range check early.
+ if (end === undefined) {
+ end = buf.length;
+ } else {
+ validateOffset(end, 'end', 0, buf.length);
+ }
+ if (offset >= end)
+ return buf;
+ }
+
+
+ if (typeof value === 'number') {
+ // OOB check
+ const byteLen = TypedArrayPrototypeGetByteLength(buf);
+ const fillLength = end - offset;
+ if (offset > end || fillLength + offset > byteLen)
+ throw new ERR_BUFFER_OUT_OF_BOUNDS();
+
+ TypedArrayPrototypeFill(buf, value, offset, end);
+ } else {
+ const res = bindingFill(buf, value, offset, end, encoding);
+ if (res < 0) {
+ if (res === -1)
+ throw new ERR_INVALID_ARG_VALUE('value', value);
+ throw new ERR_BUFFER_OUT_OF_BOUNDS();
+ }
+ }
+
+ return buf;
+}
+
+Buffer.prototype.write = function write(string, offset, length, encoding) {
+ // Buffer#write(string);
+ if (offset === undefined) {
+ return this.utf8Write(string, 0, this.length);
+ }
+ // Buffer#write(string, encoding)
+ if (length === undefined && typeof offset === 'string') {
+ encoding = offset;
+ length = this.length;
+ offset = 0;
+
+ // Buffer#write(string, offset[, length][, encoding])
+ } else {
+ validateOffset(offset, 'offset', 0, this.length);
+
+ const remaining = this.length - offset;
+
+ if (length === undefined) {
+ length = remaining;
+ } else if (typeof length === 'string') {
+ encoding = length;
+ length = remaining;
+ } else {
+ validateOffset(length, 'length', 0, this.length);
+ if (length > remaining)
+ length = remaining;
+ }
+ }
+
+ if (!encoding || encoding === 'utf8')
+ return this.utf8Write(string, offset, length);
+ if (encoding === 'ascii')
+ return this.asciiWrite(string, offset, length);
+
+ const ops = getEncodingOps(encoding);
+ if (ops === undefined)
+ throw new ERR_UNKNOWN_ENCODING(encoding);
+ return ops.write(this, string, offset, length);
+};
+
+Buffer.prototype.toJSON = function toJSON() {
+ if (this.length > 0) {
+ const data = new Array(this.length);
+ for (let i = 0; i < this.length; ++i)
+ data[i] = this[i];
+ return { type: 'Buffer', data };
+ }
+ return { type: 'Buffer', data: [] };
+};
+
+function adjustOffset(offset, length) {
+ // Use Math.trunc() to convert offset to an integer value that can be larger
+ // than an Int32. Hence, don't use offset | 0 or similar techniques.
+ offset = MathTrunc(offset);
+ if (offset === 0) {
+ return 0;
+ }
+ if (offset < 0) {
+ offset += length;
+ return offset > 0 ? offset : 0;
+ }
+ if (offset < length) {
+ return offset;
+ }
+ return NumberIsNaN(offset) ? 0 : length;
+}
+
+Buffer.prototype.subarray = function subarray(start, end) {
+ const srcLength = this.length;
+ start = adjustOffset(start, srcLength);
+ end = end !== undefined ? adjustOffset(end, srcLength) : srcLength;
+ const newLength = end > start ? end - start : 0;
+ return new FastBuffer(this.buffer, this.byteOffset + start, newLength);
+};
+
+Buffer.prototype.slice = function slice(start, end) {
+ return this.subarray(start, end);
+};
+
+function swap(b, n, m) {
+ const i = b[n];
+ b[n] = b[m];
+ b[m] = i;
+}
+
+Buffer.prototype.swap16 = function swap16() {
+ // For Buffer.length < 128, it's generally faster to
+ // do the swap in javascript. For larger buffers,
+ // dropping down to the native code is faster.
+ const len = this.length;
+ if (len % 2 !== 0)
+ throw new ERR_INVALID_BUFFER_SIZE('16-bits');
+ if (len < 128) {
+ for (let i = 0; i < len; i += 2)
+ swap(this, i, i + 1);
+ return this;
+ }
+ return _swap16(this);
+};
+
+Buffer.prototype.swap32 = function swap32() {
+ // For Buffer.length < 192, it's generally faster to
+ // do the swap in javascript. For larger buffers,
+ // dropping down to the native code is faster.
+ const len = this.length;
+ if (len % 4 !== 0)
+ throw new ERR_INVALID_BUFFER_SIZE('32-bits');
+ if (len < 192) {
+ for (let i = 0; i < len; i += 4) {
+ swap(this, i, i + 3);
+ swap(this, i + 1, i + 2);
+ }
+ return this;
+ }
+ return _swap32(this);
+};
+
+Buffer.prototype.swap64 = function swap64() {
+ // For Buffer.length < 192, it's generally faster to
+ // do the swap in javascript. For larger buffers,
+ // dropping down to the native code is faster.
+ const len = this.length;
+ if (len % 8 !== 0)
+ throw new ERR_INVALID_BUFFER_SIZE('64-bits');
+ if (len < 192) {
+ for (let i = 0; i < len; i += 8) {
+ swap(this, i, i + 7);
+ swap(this, i + 1, i + 6);
+ swap(this, i + 2, i + 5);
+ swap(this, i + 3, i + 4);
+ }
+ return this;
+ }
+ return _swap64(this);
+};
+
+Buffer.prototype.toLocaleString = Buffer.prototype.toString;
+
+let transcode;
+if (internalBinding('config').hasIntl) {
+ const {
+ icuErrName,
+ transcode: _transcode,
+ } = internalBinding('icu');
+
+ // Transcodes the Buffer from one encoding to another, returning a new
+ // Buffer instance.
+ transcode = function transcode(source, fromEncoding, toEncoding) {
+ if (!isUint8Array(source)) {
+ throw new ERR_INVALID_ARG_TYPE('source',
+ ['Buffer', 'Uint8Array'], source);
+ }
+ if (source.length === 0) return Buffer.alloc(0);
+
+ fromEncoding = normalizeEncoding(fromEncoding) || fromEncoding;
+ toEncoding = normalizeEncoding(toEncoding) || toEncoding;
+ const result = _transcode(source, fromEncoding, toEncoding);
+ if (typeof result !== 'number')
+ return result;
+
+ const code = icuErrName(result);
+ const err = genericNodeError(
+ `Unable to transcode Buffer [${code}]`,
+ { code: code, errno: result },
+ );
+ throw err;
+ };
+}
+
+function btoa(input) {
+ // The implementation here has not been performance optimized in any way and
+ // should not be.
+ // Refs: https://github.com/nodejs/node/pull/38433#issuecomment-828426932
+ if (arguments.length === 0) {
+ throw new ERR_MISSING_ARGS('input');
+ }
+ const result = _btoa(`${input}`);
+ if (result === -1) {
+ throw lazyDOMException('Invalid character', 'InvalidCharacterError');
+ }
+ return result;
+}
+
+function atob(input) {
+ if (arguments.length === 0) {
+ throw new ERR_MISSING_ARGS('input');
+ }
+
+ const result = _atob(`${input}`);
+
+ switch (result) {
+ case -2: // Invalid character
+ throw lazyDOMException('Invalid character', 'InvalidCharacterError');
+ case -1: // Single character remained
+ throw lazyDOMException(
+ 'The string to be decoded is not correctly encoded.',
+ 'InvalidCharacterError');
+ case -3: // Possible overflow
+ // TODO(@anonrig): Throw correct error in here.
+ throw lazyDOMException('The input causes overflow.', 'InvalidCharacterError');
+ default:
+ return result;
+ }
+}
+
+function isUtf8(input) {
+ if (isTypedArray(input) || isAnyArrayBuffer(input)) {
+ return bindingIsUtf8(input);
+ }
+
+ throw new ERR_INVALID_ARG_TYPE('input', ['ArrayBuffer', 'Buffer', 'TypedArray'], input);
+}
+
+function isAscii(input) {
+ if (isTypedArray(input) || isAnyArrayBuffer(input)) {
+ return bindingIsAscii(input);
+ }
+
+ throw new ERR_INVALID_ARG_TYPE('input', ['ArrayBuffer', 'Buffer', 'TypedArray'], input);
+}
+
+module.exports = {
+ Buffer,
+ SlowBuffer: deprecate(
+ SlowBuffer,
+ 'SlowBuffer() is deprecated. Please use Buffer.allocUnsafeSlow()',
+ 'DEP0030'),
+ transcode,
+ isUtf8,
+ isAscii,
+
+ // Legacy
+ kMaxLength,
+ kStringMaxLength,
+ btoa,
+ atob,
+};
+
+ObjectDefineProperties(module.exports, {
+ constants: {
+ __proto__: null,
+ configurable: false,
+ enumerable: true,
+ value: constants,
+ },
+ INSPECT_MAX_BYTES: {
+ __proto__: null,
+ configurable: true,
+ enumerable: true,
+ get() { return INSPECT_MAX_BYTES; },
+ set(val) {
+ validateNumber(val, 'INSPECT_MAX_BYTES', 0);
+ INSPECT_MAX_BYTES = val;
+ },
+ },
+});
+
+defineLazyProperties(
+ module.exports,
+ 'internal/blob',
+ ['Blob', 'resolveObjectURL'],
+);
+defineLazyProperties(
+ module.exports,
+ 'internal/file',
+ ['File'],
+);
\ No newline at end of file
diff --git a/.idx/node/dfn.js b/.idx/node/dfn.js
new file mode 100644
index 0000000..29b453d
--- /dev/null
+++ b/.idx/node/dfn.js
@@ -0,0 +1,118 @@
+var dfnMapTarget = -1;
+var dfnMapDone = 0;
+var dfnMap = {};
+document.addEventListener('DOMContentLoaded', function (event) {
+ var links = [];
+ dfnMapTarget = document.links.length;
+ for (var i = 0; i < dfnMapTarget; i += 1)
+ links[i] = document.links[i];
+ var inc = 100;
+ for (var i = 0; i < dfnMapTarget; i += inc) {
+ setTimeout(function (j) {
+ for (var k = j; k < j+inc && k < dfnMapTarget; k += 1) {
+ if (links[k].href.indexOf('#') >= 0) {
+ if (links[k].className != "no-backref" &&
+ links[k].parentNode.className != "no-backref") {
+ var s = links[k].href.substr(links[k].href.indexOf('#') + 1);
+ if (!(s in dfnMap))
+ dfnMap[s] = [];
+ dfnMap[s].push(links[k]);
+ }
+ }
+ dfnMapDone += 1;
+ }
+ }, 0, i);
+ }
+ document.body.className += " dfnEnabled";
+}, false);
+
+var dfnPanel;
+var dfnUniqueId = 0;
+var dfnTimeout;
+document.addEventListener('click', dfnShow, false);
+function dfnShow(event) {
+ if (dfnTimeout) {
+ clearTimeout(dfnTimeout);
+ dfnTimeout = null;
+ }
+ if (dfnPanel) {
+ dfnPanel.parentNode.removeChild(dfnPanel);
+ dfnPanel = null;
+ }
+ if (dfnMapDone == dfnMapTarget) {
+ var node = event.target;
+ while (node && (node.nodeType != event.target.ELEMENT_NODE || node.tagName != "DFN"))
+ node = node.parentNode;
+ if (node) {
+ var panel = document.createElement('div');
+ panel.className = 'dfnPanel';
+ if (node.id) {
+ var permalinkP = document.createElement('p');
+ var permalinkA = document.createElement('a');
+ permalinkA.href = '#' + node.id;
+ permalinkA.textContent = '#' + node.id;
+ permalinkP.appendChild(permalinkA);
+ panel.appendChild(permalinkP);
+ }
+ var p = document.createElement('p');
+ panel.appendChild(p);
+ if (node.id in dfnMap || node.parentNode.id in dfnMap) {
+ p.textContent = 'Referenced in:';
+ var ul = document.createElement('ul');
+ var lastHeader;
+ var lastLi;
+ var n;
+ var sourceLinks = [];
+ if (node.id in dfnMap)
+ for (var i = 0; i < dfnMap[node.id].length; i += 1)
+ sourceLinks.push(dfnMap[node.id][i]);
+ if (node.parentNode.id in dfnMap)
+ for (var i = 0; i < dfnMap[node.parentNode.id].length; i += 1)
+ sourceLinks.push(dfnMap[node.parentNode.id][i]);
+ for (var i = 0; i < sourceLinks.length; i += 1) {
+ var link = sourceLinks[i];
+ var header = dfnGetCaption(link);
+ var a = document.createElement('a');
+ if (!link.id)
+ link.id = 'dfnReturnLink-' + dfnUniqueId++;
+ a.href = '#' + link.id;
+ if (header != lastHeader) {
+ lastHeader = header;
+ n = 1;
+ var li = document.createElement('li');
+ var cloneHeader = header.cloneNode(true);
+ while (cloneHeader.hasChildNodes())
+ if (cloneHeader.firstChild.className == 'section-link')
+ cloneHeader.removeChild(cloneHeader.firstChild);
+ else
+ a.appendChild(cloneHeader.firstChild);
+ lastLi = li;
+ li.appendChild(a);
+ ul.appendChild(li);
+ } else {
+ n += 1;
+ a.appendChild(document.createTextNode('(' + n + ')'));
+ lastLi.appendChild(document.createTextNode(' '));
+ lastLi.appendChild(a);
+ }
+ }
+ panel.appendChild(ul);
+ } else {
+ p.textContent = 'No references in this file.';
+ }
+ node.appendChild(panel);
+ dfnPanel = panel;
+ }
+ } else {
+ dfnTimeout = setTimeout(dfnShow, 250, event);
+ }
+}
+
+function dfnGetCaption(link) {
+ var node = link;
+ while (node && !(node.parentNode.tagName == "DIV" && node.parentNode.className == "section"))
+ node = node.parentNode;
+ while (node && (node.nodeType != node.ELEMENT_NODE || !node.tagName.match(/^H[1-6]$/)))
+ node = node.previousSibling;
+ return node;
+}
\ No newline at end of file
diff --git a/.idx/node/dgram.js b/.idx/node/dgram.js
new file mode 100644
index 0000000..c77ea89
--- /dev/null
+++ b/.idx/node/dgram.js
@@ -0,0 +1,1111 @@
+'use strict';
+
+const {
+ Array,
+ ArrayIsArray,
+ ArrayPrototypePush,
+ FunctionPrototypeBind,
+ FunctionPrototypeCall,
+ ObjectDefineProperty,
+ ObjectSetPrototypeOf,
+ ReflectApply,
+ SymbolAsyncDispose,
+ SymbolDispose,
+} = primordials;
+
+const {
+ ErrnoException,
+ ExceptionWithHostPort,
+ codes: {
+ ERR_BUFFER_OUT_OF_BOUNDS,
+ ERR_INVALID_ARG_TYPE,
+ ERR_INVALID_FD_TYPE,
+ ERR_IP_BLOCKED,
+ ERR_MISSING_ARGS,
+ ERR_SOCKET_ALREADY_BOUND,
+ ERR_SOCKET_BAD_BUFFER_SIZE,
+ ERR_SOCKET_BUFFER_SIZE,
+ ERR_SOCKET_DGRAM_IS_CONNECTED,
+ ERR_SOCKET_DGRAM_NOT_CONNECTED,
+ ERR_SOCKET_DGRAM_NOT_RUNNING,
+ },
+} = require('internal/errors');
+const {
+ kStateSymbol,
+ _createSocketHandle,
+ newHandle,
+} = require('internal/dgram');
+const { isIP } = require('internal/net');
+const {
+ isInt32,
+ validateAbortSignal,
+ validateString,
+ validateNumber,
+ validatePort,
+ validateUint32,
+} = require('internal/validators');
+const { Buffer } = require('buffer');
+const { deprecate, guessHandleType, promisify } = require('internal/util');
+const { isArrayBufferView } = require('internal/util/types');
+const EventEmitter = require('events');
+const { addAbortListener } = require('internal/events/abort_listener');
+const {
+ defaultTriggerAsyncIdScope,
+ symbols: { async_id_symbol, owner_symbol },
+} = require('internal/async_hooks');
+const { UV_UDP_REUSEADDR } = internalBinding('constants').os;
+
+const {
+ constants: { UV_UDP_IPV6ONLY, UV_UDP_REUSEPORT },
+ UDP,
+ SendWrap,
+} = internalBinding('udp_wrap');
+
+const dc = require('diagnostics_channel');
+const udpSocketChannel = dc.channel('udp.socket');
+
+const BIND_STATE_UNBOUND = 0;
+const BIND_STATE_BINDING = 1;
+const BIND_STATE_BOUND = 2;
+
+const CONNECT_STATE_DISCONNECTED = 0;
+const CONNECT_STATE_CONNECTING = 1;
+const CONNECT_STATE_CONNECTED = 2;
+
+const RECV_BUFFER = true;
+const SEND_BUFFER = false;
+
+// Lazily loaded
+let _cluster = null;
+function lazyLoadCluster() {
+ return _cluster ??= require('cluster');
+}
+let _blockList = null;
+function lazyLoadBlockList() {
+ return _blockList ??= require('internal/blocklist').BlockList;
+}
+
+function Socket(type, listener) {
+ FunctionPrototypeCall(EventEmitter, this);
+ let lookup;
+ let recvBufferSize;
+ let sendBufferSize;
+ let receiveBlockList;
+ let sendBlockList;
+
+ let options;
+ if (type !== null && typeof type === 'object') {
+ options = type;
+ type = options.type;
+ lookup = options.lookup;
+ if (options.recvBufferSize) {
+ validateUint32(options.recvBufferSize, 'options.recvBufferSize');
+ }
+ if (options.sendBufferSize) {
+ validateUint32(options.sendBufferSize, 'options.sendBufferSize');
+ }
+ recvBufferSize = options.recvBufferSize;
+ sendBufferSize = options.sendBufferSize;
+ if (options.receiveBlockList) {
+ if (!lazyLoadBlockList().isBlockList(options.receiveBlockList)) {
+ throw new ERR_INVALID_ARG_TYPE('options.receiveBlockList', 'net.BlockList', options.receiveBlockList);
+ }
+ receiveBlockList = options.receiveBlockList;
+ }
+ if (options.sendBlockList) {
+ if (!lazyLoadBlockList().isBlockList(options.sendBlockList)) {
+ throw new ERR_INVALID_ARG_TYPE('options.sendBlockList', 'net.BlockList', options.sendBlockList);
+ }
+ sendBlockList = options.sendBlockList;
+ }
+ }
+
+ const handle = newHandle(type, lookup);
+ handle[owner_symbol] = this;
+
+ this[async_id_symbol] = handle.getAsyncId();
+ this.type = type;
+
+ if (typeof listener === 'function')
+ this.on('message', listener);
+
+ this[kStateSymbol] = {
+ handle,
+ receiving: false,
+ bindState: BIND_STATE_UNBOUND,
+ connectState: CONNECT_STATE_DISCONNECTED,
+ queue: undefined,
+ reuseAddr: options?.reuseAddr, // Use UV_UDP_REUSEADDR if true.
+ reusePort: options?.reusePort,
+ ipv6Only: options?.ipv6Only,
+ recvBufferSize,
+ sendBufferSize,
+ receiveBlockList,
+ sendBlockList,
+ };
+
+ if (options?.signal !== undefined) {
+ const { signal } = options;
+ validateAbortSignal(signal, 'options.signal');
+ const onAborted = () => {
+ if (this[kStateSymbol].handle) this.close();
+ };
+ if (signal.aborted) {
+ onAborted();
+ } else {
+ const disposable = addAbortListener(signal, onAborted);
+ this.once('close', disposable[SymbolDispose]);
+ }
+ }
+ if (udpSocketChannel.hasSubscribers) {
+ udpSocketChannel.publish({
+ socket: this,
+ });
+ }
+}
+ObjectSetPrototypeOf(Socket.prototype, EventEmitter.prototype);
+ObjectSetPrototypeOf(Socket, EventEmitter);
+
+
+function createSocket(type, listener) {
+ return new Socket(type, listener);
+}
+
+
+function startListening(socket) {
+ const state = socket[kStateSymbol];
+
+ state.handle.onmessage = onMessage;
+ state.handle.onerror = onError;
+ state.handle.recvStart();
+ state.receiving = true;
+ state.bindState = BIND_STATE_BOUND;
+
+ if (state.recvBufferSize)
+ bufferSize(socket, state.recvBufferSize, RECV_BUFFER);
+
+ if (state.sendBufferSize)
+ bufferSize(socket, state.sendBufferSize, SEND_BUFFER);
+
+ socket.emit('listening');
+}
+
+function replaceHandle(self, newHandle) {
+ const state = self[kStateSymbol];
+ const oldHandle = state.handle;
+ // Sync the old handle state to new handle
+ if (!oldHandle.hasRef() && typeof newHandle.unref === 'function') {
+ newHandle.unref();
+ }
+ // Set up the handle that we got from primary.
+ newHandle.lookup = oldHandle.lookup;
+ newHandle.bind = oldHandle.bind;
+ newHandle.send = oldHandle.send;
+ newHandle[owner_symbol] = self;
+
+ // Replace the existing handle by the handle we got from primary.
+ oldHandle.close();
+ state.handle = newHandle;
+}
+
+function bufferSize(self, size, buffer) {
+ if (size >>> 0 !== size)
+ throw new ERR_SOCKET_BAD_BUFFER_SIZE();
+
+ const ctx = {};
+ const ret = self[kStateSymbol].handle.bufferSize(size, buffer, ctx);
+ if (ret === undefined) {
+ throw new ERR_SOCKET_BUFFER_SIZE(ctx);
+ }
+ return ret;
+}
+
+// Query primary process to get the server handle and utilize it.
+function bindServerHandle(self, options, errCb) {
+ const cluster = lazyLoadCluster();
+
+ const state = self[kStateSymbol];
+ cluster._getServer(self, options, (err, handle) => {
+ if (err) {
+ // Do not call callback if socket is closed
+ if (state.handle) {
+ errCb(err);
+ }
+ return;
+ }
+
+ if (!state.handle) {
+ // Handle has been closed in the mean time.
+ return handle.close();
+ }
+
+ replaceHandle(self, handle);
+ startListening(self);
+ });
+}
+
+Socket.prototype.bind = function(port_, address_ /* , callback */) {
+ let port = port_;
+
+ healthCheck(this);
+ const state = this[kStateSymbol];
+
+ if (state.bindState !== BIND_STATE_UNBOUND)
+ throw new ERR_SOCKET_ALREADY_BOUND();
+
+ state.bindState = BIND_STATE_BINDING;
+
+ const cb = arguments.length && arguments[arguments.length - 1];
+ if (typeof cb === 'function') {
+ function removeListeners() {
+ this.removeListener('error', removeListeners);
+ this.removeListener('listening', onListening);
+ }
+
+ function onListening() {
+ FunctionPrototypeCall(removeListeners, this);
+ FunctionPrototypeCall(cb, this);
+ }
+
+ this.on('error', removeListeners);
+ this.on('listening', onListening);
+ }
+
+ if (port !== null &&
+ typeof port === 'object' &&
+ typeof port.recvStart === 'function') {
+ replaceHandle(this, port);
+ startListening(this);
+ return this;
+ }
+
+ // Open an existing fd instead of creating a new one.
+ if (port !== null && typeof port === 'object' &&
+ isInt32(port.fd) && port.fd > 0) {
+ const fd = port.fd;
+ const exclusive = !!port.exclusive;
+ const state = this[kStateSymbol];
+
+ const cluster = lazyLoadCluster();
+
+ if (cluster.isWorker && !exclusive) {
+ bindServerHandle(this, {
+ address: null,
+ port: null,
+ addressType: this.type,
+ fd,
+ flags: null,
+ }, (err) => {
+ // Callback to handle error.
+ const ex = new ErrnoException(err, 'open');
+ state.bindState = BIND_STATE_UNBOUND;
+ this.emit('error', ex);
+ });
+ return this;
+ }
+
+ const type = guessHandleType(fd);
+ if (type !== 'UDP')
+ throw new ERR_INVALID_FD_TYPE(type);
+ const err = state.handle.open(fd);
+
+ if (err)
+ throw new ErrnoException(err, 'open');
+
+ startListening(this);
+ return this;
+ }
+
+ let address;
+ let exclusive;
+
+ if (port !== null && typeof port === 'object') {
+ address = port.address || '';
+ exclusive = !!port.exclusive;
+ port = port.port;
+ } else {
+ address = typeof address_ === 'function' ? '' : address_;
+ exclusive = false;
+ }
+
+ // Defaulting address for bind to all interfaces
+ if (!address) {
+ if (this.type === 'udp4')
+ address = '0.0.0.0';
+ else
+ address = '::';
+ }
+
+ // Resolve address first
+ state.handle.lookup(address, (err, ip) => {
+ if (!state.handle)
+ return; // Handle has been closed in the mean time
+
+ if (err) {
+ state.bindState = BIND_STATE_UNBOUND;
+ this.emit('error', err);
+ return;
+ }
+
+ const cluster = lazyLoadCluster();
+
+ let flags = 0;
+ if (state.reuseAddr)
+ flags |= UV_UDP_REUSEADDR;
+ if (state.ipv6Only)
+ flags |= UV_UDP_IPV6ONLY;
+ if (state.reusePort) {
+ exclusive = true;
+ flags |= UV_UDP_REUSEPORT;
+ }
+
+ if (cluster.isWorker && !exclusive) {
+ bindServerHandle(this, {
+ address: ip,
+ port: port,
+ addressType: this.type,
+ fd: -1,
+ flags: flags,
+ }, (err) => {
+ // Callback to handle error.
+ const ex = new ExceptionWithHostPort(err, 'bind', ip, port);
+ state.bindState = BIND_STATE_UNBOUND;
+ this.emit('error', ex);
+ });
+ } else {
+ const err = state.handle.bind(ip, port || 0, flags);
+ if (err) {
+ const ex = new ExceptionWithHostPort(err, 'bind', ip, port);
+ state.bindState = BIND_STATE_UNBOUND;
+ this.emit('error', ex);
+ // Todo: close?
+ return;
+ }
+
+ startListening(this);
+ }
+ });
+
+ return this;
+};
+
+Socket.prototype.connect = function(port, address, callback) {
+ port = validatePort(port, 'Port', false);
+ if (typeof address === 'function') {
+ callback = address;
+ address = '';
+ } else if (address === undefined) {
+ address = '';
+ }
+
+ validateString(address, 'address');
+
+ const state = this[kStateSymbol];
+
+ if (state.connectState !== CONNECT_STATE_DISCONNECTED)
+ throw new ERR_SOCKET_DGRAM_IS_CONNECTED();
+
+ state.connectState = CONNECT_STATE_CONNECTING;
+ if (state.bindState === BIND_STATE_UNBOUND)
+ this.bind({ port: 0, exclusive: true }, null);
+
+ if (state.bindState !== BIND_STATE_BOUND) {
+ enqueue(this, FunctionPrototypeBind(_connect, this,
+ port, address, callback));
+ return;
+ }
+
+ ReflectApply(_connect, this, [port, address, callback]);
+};
+
+
+function _connect(port, address, callback) {
+ const state = this[kStateSymbol];
+ if (callback)
+ this.once('connect', callback);
+
+ const afterDns = (ex, ip) => {
+ defaultTriggerAsyncIdScope(
+ this[async_id_symbol],
+ doConnect,
+ ex, this, ip, address, port, callback,
+ );
+ };
+
+ state.handle.lookup(address, afterDns);
+}
+
+
+function doConnect(ex, self, ip, address, port, callback) {
+ const state = self[kStateSymbol];
+ if (!state.handle)
+ return;
+ if (!ex && state.sendBlockList?.check(ip, `ipv${isIP(ip)}`)) {
+ ex = new ERR_IP_BLOCKED(ip);
+ }
+ if (!ex) {
+ const err = state.handle.connect(ip, port);
+ if (err) {
+ ex = new ExceptionWithHostPort(err, 'connect', address, port);
+ }
+ }
+
+ if (ex) {
+ state.connectState = CONNECT_STATE_DISCONNECTED;
+ return process.nextTick(() => {
+ if (callback) {
+ self.removeListener('connect', callback);
+ callback(ex);
+ } else {
+ self.emit('error', ex);
+ }
+ });
+ }
+
+ state.connectState = CONNECT_STATE_CONNECTED;
+ process.nextTick(() => self.emit('connect'));
+}
+
+
+Socket.prototype.disconnect = function() {
+ const state = this[kStateSymbol];
+ if (state.connectState !== CONNECT_STATE_CONNECTED)
+ throw new ERR_SOCKET_DGRAM_NOT_CONNECTED();
+
+ const err = state.handle.disconnect();
+ if (err)
+ throw new ErrnoException(err, 'connect');
+ else
+ state.connectState = CONNECT_STATE_DISCONNECTED;
+};
+
+
+// Thin wrapper around `send`, here for compatibility with dgram_legacy.js
+Socket.prototype.sendto = function(buffer,
+ offset,
+ length,
+ port,
+ address,
+ callback) {
+ validateNumber(offset, 'offset');
+ validateNumber(length, 'length');
+ validateNumber(port, 'port');
+ validateString(address, 'address');
+
+ this.send(buffer, offset, length, port, address, callback);
+};
+
+
+function sliceBuffer(buffer, offset, length) {
+ if (typeof buffer === 'string') {
+ buffer = Buffer.from(buffer);
+ } else if (!isArrayBufferView(buffer)) {
+ throw new ERR_INVALID_ARG_TYPE('buffer',
+ ['Buffer',
+ 'TypedArray',
+ 'DataView',
+ 'string'],
+ buffer);
+ }
+
+ offset = offset >>> 0;
+ length = length >>> 0;
+ if (offset > buffer.byteLength) {
+ throw new ERR_BUFFER_OUT_OF_BOUNDS('offset');
+ }
+
+ if (offset + length > buffer.byteLength) {
+ throw new ERR_BUFFER_OUT_OF_BOUNDS('length');
+ }
+
+ return Buffer.from(buffer.buffer, buffer.byteOffset + offset, length);
+}
+
+
+function fixBufferList(list) {
+ const newlist = new Array(list.length);
+
+ for (let i = 0, l = list.length; i < l; i++) {
+ const buf = list[i];
+ if (typeof buf === 'string')
+ newlist[i] = Buffer.from(buf);
+ else if (Buffer.isBuffer(buf))
+ newlist[i] = buf;
+ else if (!isArrayBufferView(buf))
+ return null;
+ else
+ newlist[i] = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+ }
+
+ return newlist;
+}
+
+
+function enqueue(self, toEnqueue) {
+ const state = self[kStateSymbol];
+
+ // If the send queue hasn't been initialized yet, do it, and install an
+ // event handler that flushes the send queue after binding is done.
+ if (state.queue === undefined) {
+ state.queue = [];
+ self.once(EventEmitter.errorMonitor, onListenError);
+ self.once('listening', onListenSuccess);
+ }
+ ArrayPrototypePush(state.queue, toEnqueue);
+}
+
+
+function onListenSuccess() {
+ this.removeListener(EventEmitter.errorMonitor, onListenError);
+ FunctionPrototypeCall(clearQueue, this);
+}
+
+
+function onListenError(err) {
+ this.removeListener('listening', onListenSuccess);
+ this[kStateSymbol].queue = undefined;
+}
+
+
+function clearQueue() {
+ const state = this[kStateSymbol];
+ const queue = state.queue;
+ state.queue = undefined;
+
+ // Flush the send queue.
+ for (const queueEntry of queue)
+ queueEntry();
+}
+
+// valid combinations
+// For connectionless sockets
+// send(buffer, offset, length, port, address, callback)
+// send(buffer, offset, length, port, address)
+// send(buffer, offset, length, port, callback)
+// send(buffer, offset, length, port)
+// send(bufferOrList, port, address, callback)
+// send(bufferOrList, port, address)
+// send(bufferOrList, port, callback)
+// send(bufferOrList, port)
+// For connected sockets
+// send(buffer, offset, length, callback)
+// send(buffer, offset, length)
+// send(bufferOrList, callback)
+// send(bufferOrList)
+Socket.prototype.send = function(buffer,
+ offset,
+ length,
+ port,
+ address,
+ callback) {
+
+ let list;
+ const state = this[kStateSymbol];
+ const connected = state.connectState === CONNECT_STATE_CONNECTED;
+ if (!connected) {
+ if (address || (port && typeof port !== 'function')) {
+ buffer = sliceBuffer(buffer, offset, length);
+ } else {
+ callback = port;
+ port = offset;
+ address = length;
+ }
+ } else {
+ if (typeof length === 'number') {
+ buffer = sliceBuffer(buffer, offset, length);
+ if (typeof port === 'function') {
+ callback = port;
+ port = null;
+ }
+ } else {
+ callback = offset;
+ }
+
+ if (port || address)
+ throw new ERR_SOCKET_DGRAM_IS_CONNECTED();
+ }
+
+ if (!ArrayIsArray(buffer)) {
+ if (typeof buffer === 'string') {
+ list = [ Buffer.from(buffer) ];
+ } else if (!isArrayBufferView(buffer)) {
+ throw new ERR_INVALID_ARG_TYPE('buffer',
+ ['Buffer',
+ 'TypedArray',
+ 'DataView',
+ 'string'],
+ buffer);
+ } else {
+ list = [ buffer ];
+ }
+ } else if (!(list = fixBufferList(buffer))) {
+ throw new ERR_INVALID_ARG_TYPE('buffer list arguments',
+ ['Buffer',
+ 'TypedArray',
+ 'DataView',
+ 'string'],
+ buffer);
+ }
+
+ if (!connected)
+ port = validatePort(port, 'Port', false);
+
+ // Normalize callback so it's either a function or undefined but not anything
+ // else.
+ if (typeof callback !== 'function')
+ callback = undefined;
+
+ if (typeof address === 'function') {
+ callback = address;
+ address = undefined;
+ } else if (address != null) {
+ validateString(address, 'address');
+ }
+
+ healthCheck(this);
+
+ if (state.bindState === BIND_STATE_UNBOUND)
+ this.bind({ port: 0, exclusive: true }, null);
+
+ if (list.length === 0)
+ ArrayPrototypePush(list, Buffer.alloc(0));
+
+ // If the socket hasn't been bound yet, push the outbound packet onto the
+ // send queue and send after binding is complete.
+ if (state.bindState !== BIND_STATE_BOUND) {
+ enqueue(this, FunctionPrototypeBind(this.send, this,
+ list, port, address, callback));
+ return;
+ }
+
+ const afterDns = (ex, ip) => {
+ defaultTriggerAsyncIdScope(
+ this[async_id_symbol],
+ doSend,
+ ex, this, ip, list, address, port, callback,
+ );
+ };
+
+ if (!connected) {
+ state.handle.lookup(address, afterDns);
+ } else {
+ afterDns(null, null);
+ }
+};
+
+function doSend(ex, self, ip, list, address, port, callback) {
+ const state = self[kStateSymbol];
+
+ if (ex) {
+ if (typeof callback === 'function') {
+ process.nextTick(callback, ex);
+ return;
+ }
+
+ process.nextTick(() => self.emit('error', ex));
+ return;
+ } else if (!state.handle) {
+ return;
+ }
+
+ if (ip && state.sendBlockList?.check(ip, `ipv${isIP(ip)}`)) {
+ if (callback) {
+ process.nextTick(callback, new ERR_IP_BLOCKED(ip));
+ }
+ return;
+ }
+
+ const req = new SendWrap();
+ req.list = list; // Keep reference alive.
+ req.address = address;
+ req.port = port;
+ if (callback) {
+ req.callback = callback;
+ req.oncomplete = afterSend;
+ }
+
+ let err;
+ if (port)
+ err = state.handle.send(req, list, list.length, port, ip, !!callback);
+ else
+ err = state.handle.send(req, list, list.length, !!callback);
+
+ if (err >= 1) {
+ // Synchronous finish. The return code is msg_length + 1 so that we can
+ // distinguish between synchronous success and asynchronous success.
+ if (callback)
+ process.nextTick(callback, null, err - 1);
+ return;
+ }
+
+ if (err && callback) {
+ // Don't emit as error, dgram_legacy.js compatibility
+ const ex = new ExceptionWithHostPort(err, 'send', address, port);
+ process.nextTick(callback, ex);
+ }
+}
+
+function afterSend(err, sent) {
+ if (err) {
+ err = new ExceptionWithHostPort(err, 'send', this.address, this.port);
+ } else {
+ err = null;
+ }
+
+ this.callback(err, sent);
+}
+
+Socket.prototype.close = function(callback) {
+ const state = this[kStateSymbol];
+ const queue = state.queue;
+
+ if (typeof callback === 'function')
+ this.on('close', callback);
+
+ if (queue !== undefined) {
+ ArrayPrototypePush(queue, FunctionPrototypeBind(this.close, this));
+ return this;
+ }
+
+ healthCheck(this);
+ stopReceiving(this);
+ state.handle.close();
+ state.handle = null;
+ defaultTriggerAsyncIdScope(this[async_id_symbol],
+ process.nextTick,
+ socketCloseNT,
+ this);
+
+ return this;
+};
+
+Socket.prototype[SymbolAsyncDispose] = async function() {
+ if (!this[kStateSymbol].handle) {
+ return;
+ }
+ await FunctionPrototypeCall(promisify(this.close), this);
+};
+
+
+function socketCloseNT(self) {
+ self.emit('close');
+}
+
+
+Socket.prototype.address = function() {
+ healthCheck(this);
+
+ const out = {};
+ const err = this[kStateSymbol].handle.getsockname(out);
+ if (err) {
+ throw new ErrnoException(err, 'getsockname');
+ }
+
+ return out;
+};
+
+Socket.prototype.remoteAddress = function() {
+ healthCheck(this);
+
+ const state = this[kStateSymbol];
+ if (state.connectState !== CONNECT_STATE_CONNECTED)
+ throw new ERR_SOCKET_DGRAM_NOT_CONNECTED();
+
+ const out = {};
+ const err = state.handle.getpeername(out);
+ if (err)
+ throw new ErrnoException(err, 'getpeername');
+
+ return out;
+};
+
+
+Socket.prototype.setBroadcast = function(arg) {
+ const err = this[kStateSymbol].handle.setBroadcast(arg ? 1 : 0);
+ if (err) {
+ throw new ErrnoException(err, 'setBroadcast');
+ }
+};
+
+
+Socket.prototype.setTTL = function(ttl) {
+ validateNumber(ttl, 'ttl');
+
+ const err = this[kStateSymbol].handle.setTTL(ttl);
+ if (err) {
+ throw new ErrnoException(err, 'setTTL');
+ }
+
+ return ttl;
+};
+
+
+Socket.prototype.setMulticastTTL = function(ttl) {
+ validateNumber(ttl, 'ttl');
+
+ const err = this[kStateSymbol].handle.setMulticastTTL(ttl);
+ if (err) {
+ throw new ErrnoException(err, 'setMulticastTTL');
+ }
+
+ return ttl;
+};
+
+
+Socket.prototype.setMulticastLoopback = function(arg) {
+ const err = this[kStateSymbol].handle.setMulticastLoopback(arg ? 1 : 0);
+ if (err) {
+ throw new ErrnoException(err, 'setMulticastLoopback');
+ }
+
+ return arg; // 0.4 compatibility
+};
+
+
+Socket.prototype.setMulticastInterface = function(interfaceAddress) {
+ healthCheck(this);
+ validateString(interfaceAddress, 'interfaceAddress');
+
+ const err = this[kStateSymbol].handle.setMulticastInterface(interfaceAddress);
+ if (err) {
+ throw new ErrnoException(err, 'setMulticastInterface');
+ }
+};
+
+Socket.prototype.addMembership = function(multicastAddress,
+ interfaceAddress) {
+ healthCheck(this);
+
+ if (!multicastAddress) {
+ throw new ERR_MISSING_ARGS('multicastAddress');
+ }
+
+ const { handle } = this[kStateSymbol];
+ const err = handle.addMembership(multicastAddress, interfaceAddress);
+ if (err) {
+ throw new ErrnoException(err, 'addMembership');
+ }
+};
+
+
+Socket.prototype.dropMembership = function(multicastAddress,
+ interfaceAddress) {
+ healthCheck(this);
+
+ if (!multicastAddress) {
+ throw new ERR_MISSING_ARGS('multicastAddress');
+ }
+
+ const { handle } = this[kStateSymbol];
+ const err = handle.dropMembership(multicastAddress, interfaceAddress);
+ if (err) {
+ throw new ErrnoException(err, 'dropMembership');
+ }
+};
+
+Socket.prototype.addSourceSpecificMembership = function(sourceAddress,
+ groupAddress,
+ interfaceAddress) {
+ healthCheck(this);
+
+ validateString(sourceAddress, 'sourceAddress');
+ validateString(groupAddress, 'groupAddress');
+
+ const err =
+ this[kStateSymbol].handle.addSourceSpecificMembership(sourceAddress,
+ groupAddress,
+ interfaceAddress);
+ if (err) {
+ throw new ErrnoException(err, 'addSourceSpecificMembership');
+ }
+};
+
+
+Socket.prototype.dropSourceSpecificMembership = function(sourceAddress,
+ groupAddress,
+ interfaceAddress) {
+ healthCheck(this);
+
+ validateString(sourceAddress, 'sourceAddress');
+ validateString(groupAddress, 'groupAddress');
+
+ const err =
+ this[kStateSymbol].handle.dropSourceSpecificMembership(sourceAddress,
+ groupAddress,
+ interfaceAddress);
+ if (err) {
+ throw new ErrnoException(err, 'dropSourceSpecificMembership');
+ }
+};
+
+
+function healthCheck(socket) {
+ if (!socket[kStateSymbol].handle) {
+ // Error message from dgram_legacy.js.
+ throw new ERR_SOCKET_DGRAM_NOT_RUNNING();
+ }
+}
+
+
+function stopReceiving(socket) {
+ const state = socket[kStateSymbol];
+
+ if (!state.receiving)
+ return;
+
+ state.handle.recvStop();
+ state.receiving = false;
+}
+
+
+function onMessage(nread, handle, buf, rinfo) {
+ const self = handle[owner_symbol];
+ if (nread < 0) {
+ return self.emit('error', new ErrnoException(nread, 'recvmsg'));
+ }
+ if (self[kStateSymbol]?.receiveBlockList?.check(rinfo.address,
+ rinfo.family?.toLocaleLowerCase())) {
+ return;
+ }
+ rinfo.size = buf.length; // compatibility
+ self.emit('message', buf, rinfo);
+}
+
+
+function onError(nread, handle, error) {
+ const self = handle[owner_symbol];
+ return self.emit('error', error);
+}
+
+
+Socket.prototype.ref = function() {
+ const handle = this[kStateSymbol].handle;
+
+ if (handle)
+ handle.ref();
+
+ return this;
+};
+
+
+Socket.prototype.unref = function() {
+ const handle = this[kStateSymbol].handle;
+
+ if (handle)
+ handle.unref();
+
+ return this;
+};
+
+
+Socket.prototype.setRecvBufferSize = function(size) {
+ bufferSize(this, size, RECV_BUFFER);
+};
+
+
+Socket.prototype.setSendBufferSize = function(size) {
+ bufferSize(this, size, SEND_BUFFER);
+};
+
+
+Socket.prototype.getRecvBufferSize = function() {
+ return bufferSize(this, 0, RECV_BUFFER);
+};
+
+
+Socket.prototype.getSendBufferSize = function() {
+ return bufferSize(this, 0, SEND_BUFFER);
+};
+
+Socket.prototype.getSendQueueSize = function() {
+ return this[kStateSymbol].handle.getSendQueueSize();
+};
+
+Socket.prototype.getSendQueueCount = function() {
+ return this[kStateSymbol].handle.getSendQueueCount();
+};
+
+// Deprecated private APIs.
+ObjectDefineProperty(Socket.prototype, '_handle', {
+ __proto__: null,
+ get: deprecate(function() {
+ return this[kStateSymbol].handle;
+ }, 'Socket.prototype._handle is deprecated', 'DEP0112'),
+ set: deprecate(function(val) {
+ this[kStateSymbol].handle = val;
+ }, 'Socket.prototype._handle is deprecated', 'DEP0112'),
+});
+
+
+ObjectDefineProperty(Socket.prototype, '_receiving', {
+ __proto__: null,
+ get: deprecate(function() {
+ return this[kStateSymbol].receiving;
+ }, 'Socket.prototype._receiving is deprecated', 'DEP0112'),
+ set: deprecate(function(val) {
+ this[kStateSymbol].receiving = val;
+ }, 'Socket.prototype._receiving is deprecated', 'DEP0112'),
+});
+
+
+ObjectDefineProperty(Socket.prototype, '_bindState', {
+ __proto__: null,
+ get: deprecate(function() {
+ return this[kStateSymbol].bindState;
+ }, 'Socket.prototype._bindState is deprecated', 'DEP0112'),
+ set: deprecate(function(val) {
+ this[kStateSymbol].bindState = val;
+ }, 'Socket.prototype._bindState is deprecated', 'DEP0112'),
+});
+
+
+ObjectDefineProperty(Socket.prototype, '_queue', {
+ __proto__: null,
+ get: deprecate(function() {
+ return this[kStateSymbol].queue;
+ }, 'Socket.prototype._queue is deprecated', 'DEP0112'),
+ set: deprecate(function(val) {
+ this[kStateSymbol].queue = val;
+ }, 'Socket.prototype._queue is deprecated', 'DEP0112'),
+});
+
+
+ObjectDefineProperty(Socket.prototype, '_reuseAddr', {
+ __proto__: null,
+ get: deprecate(function() {
+ return this[kStateSymbol].reuseAddr;
+ }, 'Socket.prototype._reuseAddr is deprecated', 'DEP0112'),
+ set: deprecate(function(val) {
+ this[kStateSymbol].reuseAddr = val;
+ }, 'Socket.prototype._reuseAddr is deprecated', 'DEP0112'),
+});
+
+
+Socket.prototype._healthCheck = deprecate(function() {
+ healthCheck(this);
+}, 'Socket.prototype._healthCheck() is deprecated', 'DEP0112');
+
+
+Socket.prototype._stopReceiving = deprecate(function() {
+ stopReceiving(this);
+}, 'Socket.prototype._stopReceiving() is deprecated', 'DEP0112');
+
+
+// Legacy alias on the C++ wrapper object. This is not public API, so we may
+// want to runtime-deprecate it at some point. There's no hurry, though.
+ObjectDefineProperty(UDP.prototype, 'owner', {
+ __proto__: null,
+ get() { return this[owner_symbol]; },
+ set(v) { return this[owner_symbol] = v; },
+});
+
+
+module.exports = {
+ _createSocketHandle: deprecate(
+ _createSocketHandle,
+ 'dgram._createSocketHandle() is deprecated',
+ 'DEP0112',
+ ),
+ createSocket,
+ Socket,
+};
\ No newline at end of file
diff --git a/.idx/node/hello-world.js b/.idx/node/hello-world.js
new file mode 100644
index 0000000..f7ac4e4
--- /dev/null
+++ b/.idx/node/hello-world.js
@@ -0,0 +1,16 @@
+
+
+
+
+
+
+
+ {[user.firstName, user.lastName].join(" ")}
+Hello world
+
+@layer utilities {
+ .typography-h1 {
+ font: var(--mui-font-h1);
+ letter-spacing: -0.01562em;
+ }
+ .text-primary {
+ color: rgb(var(--mui-palette-primary-mainChannel));
+ }
+ }
\ No newline at end of file
diff --git a/.idx/pages/Card.css b/.idx/pages/Card.css
new file mode 100644
index 0000000..de9427f
--- /dev/null
+++ b/.idx/pages/Card.css
@@ -0,0 +1,146 @@
+@import "tailwindcss";
+@import url('https://fonts.googleapis.com/css2?family=Lexend+Deca&family=Big+Shoulders+Display:wght@700&display=swap');
+
+.card {
+ padding: 3rem;
+ color: rgba(255, 255, 255, 0.9);
+ display: flex;
+ flex-direction: column;
+ gap: 1.5rem;
+ transition: all 0.3s ease;
+ cursor: pointer;
+ position: relative;
+ border-radius: 8px;
+}
+
+.card:hover {
+ transform: translateY(-5px);
+}
+
+.card.selected {
+ transform: scale(1.02);
+ box-shadow: 0 10px 20px rgba(0, 0, 0, 0.2);
+ animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+ 0% {
+ transform: scale(1.02);
+ }
+
+ 50% {
+ transform: scale(1.05);
+ }
+
+ 100% {
+ transform: scale(1.02);
+ }
+}
+
+.card.selected::after {
+ content: '❤️';
+ position: absolute;
+ top: 1rem;
+ right: 1rem;
+ width: 32px;
+ height: 32px;
+ background-color: rgba(255, 255, 255, 0.2);
+ border-radius: 50%;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ font-size: 1.2rem;
+ animation: bounce 1s infinite;
+}
+
+@keyframes bounce {
+
+ 0%,
+ 100% {
+ transform: translateY(0);
+ }
+
+ 50% {
+ transform: translateY(-5px);
+ }
+}
+
+.card h2 {
+ font-family: 'Big Shoulders Display', cursive;
+ font-weight: 700;
+ color: rgb(242, 242, 242);
+ text-transform: uppercase;
+ font-size: 2.5rem;
+ margin: 0;
+ text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.card p {
+ font-family: 'Lexend Deca', sans-serif;
+ font-weight: 400;
+ font-size: 15px;
+ line-height: 1.6;
+ margin: 0;
+}
+
+.card-icon {
+ width: 64px;
+ height: 64px;
+ filter: drop-shadow(2px 2px 4px rgba(0, 0, 0, 0.1));
+}
+
+.learn-more {
+ font-family: 'Lexend Deca', sans-serif;
+ background-color: rgb(242, 242, 242);
+ border: 2px solid rgb(242, 242, 242);
+ border-radius: 25px;
+ padding: 0.8rem 2rem;
+ width: fit-content;
+ cursor: pointer;
+ margin-top: auto;
+ transition: all 0.3s ease;
+ font-weight: 500;
+ box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.purple {
+ background-color: rgb(147, 51, 234);
+}
+
+.purple .learn-more {
+ color: rgb(147, 51, 234);
+}
+
+.purple .learn-more:hover {
+ background-color: transparent;
+ color: rgb(242, 242, 242);
+ box-shadow: 0 6px 8px rgba(0, 0, 0, 0.2);
+}
+
+.teal {
+ background-color: rgb(20, 184, 166);
+}
+
+.teal .learn-more {
+ color: rgb(20, 184, 166);
+}
+
+.teal .learn-more:hover {
+ background-color: transparent;
+ color: rgb(242, 242, 242);
+ box-shadow: 0 6px 8px rgba(0, 0, 0, 0.2);
+}
+
+.coral {
+ background-color: rgb(251, 146, 60);
+}
+
+.coral .learn-more {
+ color: rgb(251, 146, 60);
+}
+
+.coral .learn-more:hover {
+ background-color: transparent;
+ color: rgb(242, 242, 242);
+ box-shadow: 0 6px 8px rgba(0, 0, 0, 0.2);
+}
\ No newline at end of file
diff --git a/.idx/pages/Card.tsx b/.idx/pages/Card.tsx
new file mode 100644
index 0000000..2c9bc4d
--- /dev/null
+++ b/.idx/pages/Card.tsx
@@ -0,0 +1,27 @@
+import React from 'react';
+import './Card.css';
+
+interface CardProps {
+ title: string;
+ description: string;
+ icon: string;
+ color: 'all' ;
+ isSelected: boolean;
+ onSelect: () => void;
+}
+
+const Card: React.FC
+ 
+
+ );
+};
+
+export default Card;
\ No newline at end of file
diff --git a/.idx/pages/Home.jsx b/.idx/pages/Home.jsx
new file mode 100644
index 0000000..0e555f4
--- /dev/null
+++ b/.idx/pages/Home.jsx
@@ -0,0 +1,6 @@
+import {appContentStore} from "../stores/appContentStore"
+export const Home () => {
+ const { appContent } = appContentStore()
+ return(
+ {title}
+{description}
+ +{appContent.heading}
+} \ No newline at end of file diff --git a/.idx/pages/LoginForm.jsx b/.idx/pages/LoginForm.jsx new file mode 100644 index 0000000..8be5785 --- /dev/null +++ b/.idx/pages/LoginForm.jsx @@ -0,0 +1,52 @@ +import { useState } from "react"; + +const SignupForm = () => { + const [formData, setFormData] = useState({ + email: "", + password: "", + }); + + const handleSubmit = (e) => { + e.preventDefault(); + console.log(formData); + + fetch("http://localhost:8080/users", { + method: "POST", + body: JSON.stringify({ email: formData.email, password: formData.password }), + headers: { + "Content-Type": "application/json" + } + }) + .then(() => { + // Reset form + e.target.reset() + }) + .catch(error => { + console.log(error) + }) + + }; + + return ( + + ); +}; + +export default SignupForm; \ No newline at end of file diff --git a/.idx/pages/SignupForm.jsx b/.idx/pages/SignupForm.jsx new file mode 100644 index 0000000..8be5785 --- /dev/null +++ b/.idx/pages/SignupForm.jsx @@ -0,0 +1,52 @@ +import { useState } from "react"; + +const SignupForm = () => { + const [formData, setFormData] = useState({ + email: "", + password: "", + }); + + const handleSubmit = (e) => { + e.preventDefault(); + console.log(formData); + + fetch("http://localhost:8080/users", { + method: "POST", + body: JSON.stringify({ email: formData.email, password: formData.password }), + headers: { + "Content-Type": "application/json" + } + }) + .then(() => { + // Reset form + e.target.reset() + }) + .catch(error => { + console.log(error) + }) + + }; + + return ( + + ); +}; + +export default SignupForm; \ No newline at end of file diff --git a/.idx/pages/TodoItem.tsx b/.idx/pages/TodoItem.tsx new file mode 100644 index 0000000..59dbe6e --- /dev/null +++ b/.idx/pages/TodoItem.tsx @@ -0,0 +1,24 @@ +import { Checkbox } from "@/components/ui/checkbox"; +import { Button } from "@/components/ui/button"; +import { Trash2 } from "lucide-react"; +import { useTodoStore } from "@/stores/todoStore"; + +interface TodoItemProps { + id: string; +} +export const TodoItem = ({ id }: TodoItemProps) => { + const todo = useTodoStore((state) => + state.todos.find((todo) =>todo.id === id +); + +if (!todo) return null; + +return ( +
+
+ {
+ const [text, setText] = useState("");
+ const todos = useTodoStore((state) => state.settodos);
+const { setTodos } = useTodoActions();
+ const handleSubmit = (e: React.FormEvent) => {
+ e.preventDefault();
+ if (text.trim()) {
+ const todo = {
+ text: text.trim()
+ id: Date.now().toString(),
+ completed: false,
+ }
+ setTodos([...todos, todo]);
+ setText("");
+ }
+ }
+}
\ No newline at end of file
diff --git a/.idx/pages/UserSettings.jsx b/.idx/pages/UserSettings.jsx
new file mode 100644
index 0000000..67e4a17
--- /dev/null
+++ b/.idx/pages/UserSettings.jsx
@@ -0,0 +1,9 @@
+import { create } from "zustand"
+export const useUserStore = create ((set) =>({
+ isLoggedIn: false,
+ age: 25,
+ userName: "John Doe",
+ toggleLogin: () set ((state) => ({isLoggedIn:})) !state.isLoggedIn}))
+ incrementAge: () => set ((state) => ({age: state.age +1})),
+ setUserName: (newUserName) => set ({userName:})
+})
\ No newline at end of file
diff --git a/.idx/pages/Userinfo.jsx b/.idx/pages/Userinfo.jsx
new file mode 100644
index 0000000..19415b8
--- /dev/null
+++ b/.idx/pages/Userinfo.jsx
@@ -0,0 +1,11 @@
+import { useUserStore } from "../stores/userStore"
+export const UserInfo = () => {
+ const { userName, age } = useUserStore()
+
+return (
+
+
+
+
+);
\ No newline at end of file
diff --git a/.idx/pages/_document.tsx b/.idx/pages/_document.tsx
new file mode 100644
index 0000000..21d646f
--- /dev/null
+++ b/.idx/pages/_document.tsx
@@ -0,0 +1,59 @@
++import { createEmotionCache } from '@mui/material-nextjs/v15-pagesRouter';
+ ...
+ +import type { DocumentHeadTagsProps } from '@mui/material-nextjs/v15-pagesRouter';
+ // or `v1X-pagesRouter` if you are using Next.js v1X
+
++export default function MyDocument(props: DocumentProps & DocumentHeadTagsProps) {
+ ...
+ }
+
+ MyDocument.getInitialProps = async (ctx) => {
+ const finalProps = await documentGetInitialProps(ctx, {
++ emotionCache: createEmotionCache({ enableCssLayer: true }),
+ });
+ return finalProps;
+ };
+import {
+ createCache,
+ documentGetInitialProps,
+ } from '@mui/material-nextjs/v15-pagesRouter';
+
+ // ...
+
+ MyDocument.getInitialProps = async (ctx: DocumentContext) => {
+ const finalProps = await documentGetInitialProps(ctx, {
+ emotionCache: createCache({ enableCssLayer: true }),
+ });
+ return finalProps;
+ };
+ +import {
+ + DocumentHeadTags,
+ + documentGetInitialProps,
+ +} from '@mui/material-nextjs/v15-pagesRouter';
+ // or `v1X-pagesRouter` if you are using Next.js v1X
+
+ export default function MyDocument(props) {
+ return (
+
+
+ +
++
+ {children}
++
+
+
+
+ );
+ }
\ No newline at end of file
diff --git a/.idx/pages/main.tsx b/.idx/pages/main.tsx
new file mode 100644
index 0000000..9d21c56
--- /dev/null
+++ b/.idx/pages/main.tsx
@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { createRoot } from 'react-dom/client';
+import { StyledEngineProvider } from '@mui/material/styles';
+import GlobalStyles from '@mui/material/GlobalStyles';
+
+createRoot(document.getElementById('root')!).render(
+
+
+
+
+);
\ No newline at end of file
diff --git a/.idx/pages/stores/appContentStore.jsx b/.idx/pages/stores/appContentStore.jsx
new file mode 100644
index 0000000..adb1dc6
--- /dev/null
+++ b/.idx/pages/stores/appContentStore.jsx
@@ -0,0 +1,5 @@
+import {create} from "zustand"
+export const appContentStore = create(() => ({}))
+appContent:{
+ heading: "State-Management-Zustand-js-project-todo-Special Garden Group"
+}
\ No newline at end of file
diff --git a/.idx/pages/stores/userStore.jsx b/.idx/pages/stores/userStore.jsx
new file mode 100644
index 0000000..67e4a17
--- /dev/null
+++ b/.idx/pages/stores/userStore.jsx
@@ -0,0 +1,9 @@
+import { create } from "zustand"
+export const useUserStore = create ((set) =>({
+ isLoggedIn: false,
+ age: 25,
+ userName: "John Doe",
+ toggleLogin: () set ((state) => ({isLoggedIn:})) !state.isLoggedIn}))
+ incrementAge: () => set ((state) => ({age: state.age +1})),
+ setUserName: (newUserName) => set ({userName:})
+})
\ No newline at end of file
diff --git a/.idx/pages/theme.ts b/.idx/pages/theme.ts
new file mode 100644
index 0000000..a9be90b
--- /dev/null
+++ b/.idx/pages/theme.ts
@@ -0,0 +1,12 @@
+'use client';
+import { createTheme } from '@mui/material/styles';
+
+const theme = createTheme({
+ typography: {
+ fontFamily: 'var(--font-roboto)',
+ cssVariables: true,
+ });
+ },
+});
+
+export default theme;
diff --git a/.idx/pages/timeline.jsx b/.idx/pages/timeline.jsx
new file mode 100644
index 0000000..7e4f8af
--- /dev/null
+++ b/.idx/pages/timeline.jsx
@@ -0,0 +1,15 @@
+
+
+
+
+ Secondary
+
+
+
+
+ Success
+
+
\ No newline at end of file
diff --git a/.idx/pages/todoList.tsx b/.idx/pages/todoList.tsx
new file mode 100644
index 0000000..462c795
--- /dev/null
+++ b/.idx/pages/todoList.tsx
@@ -0,0 +1,29 @@
+import { useShallow } from "zustand/shallow";
+import { usetodoStore , type Todo } from "../stores/todoStore";
+import { TodoItem } from "./TodoItem";
+import { Separator } from "@/components/ui/separator";
+
+export const TodoList => {
+ const todos: Todo[] =useTodoStore((state => state.todos);
+const isSubscribed = useSubscribed();
+ if (todos.length === 0) {
+ return(
+ []>([
+ {
+ Super(path) {
+ const { node, parentPath } = path;
+ if (parentPath.isCallExpression({ callee: node })) {
+ this.push(parentPath);
+ }
+ },
+ },
+ environmentVisitor,
+ ]);
\ No newline at end of file
diff --git a/.idx/src/tsconfig.json b/.idx/src/tsconfig.json
new file mode 100644
index 0000000..8f42215
--- /dev/null
+++ b/.idx/src/tsconfig.json
@@ -0,0 +1,10 @@
+{
+ "compilerOptions": {
+ "lib": ["esnext"],
+ "noEmit": true,
+ "isolatedModules": true,
+ "moduleResolution": "nodenext",
+ "allowImportingTsExtensions": true
+ }
+ }
+
\ No newline at end of file
diff --git a/.idx/src/webpack.config.js b/.idx/src/webpack.config.js
new file mode 100644
index 0000000..ca221f5
--- /dev/null
+++ b/.idx/src/webpack.config.js
@@ -0,0 +1,13 @@
+module: {
+ rules: [
+ {
+ loader: "babel-loader",
+ options: {
+ rootMode: "upward",
+ },
+ },
+ ];
+ }
+ module.exports = {
+ entry: ["@babel/polyfill", "./app/js"],
+ };
\ No newline at end of file
diff --git a/.idx/src/wrapper.js b/.idx/src/wrapper.js
new file mode 100644
index 0000000..409ac3a
--- /dev/null
+++ b/.idx/src/wrapper.js
@@ -0,0 +1,3 @@
+module.exports = require("babel-jest").default.createTransformer({
+ rootMode: "upward",
+ });
\ No newline at end of file
diff --git a/.idx/sum.js b/.idx/sum.js
new file mode 100644
index 0000000..c201d58
--- /dev/null
+++ b/.idx/sum.js
@@ -0,0 +1,4 @@
+function sum(a, b) {
+ return a + b;
+ }
+ module.exports = sum;
\ No newline at end of file
diff --git a/.idx/sum.test.js b/.idx/sum.test.js
new file mode 100644
index 0000000..df0dd09
--- /dev/null
+++ b/.idx/sum.test.js
@@ -0,0 +1,5 @@
+const sum = require('./sum');
+
+test('adds 1 + 2 to equal 3', () => {
+ expect(sum(1, 2)).toBe(3);
+});
\ No newline at end of file
diff --git a/.idx/tailwind.config.js b/.idx/tailwind.config.js
new file mode 100644
index 0000000..7acfb12
--- /dev/null
+++ b/.idx/tailwind.config.js
@@ -0,0 +1,27 @@
+const colors = require('tailwindcss/colors')
+module.exports = {
+ mode:'jit',
+ purge: [`./src/**/*.{js,jsx,ts,tsx}`, `./public/index.html'],
+ darkMode: 'class', // or 'media' or 'class'
+ theme: {
+ extend: {}
+ colors:{
+ bg-primary: #'202225',
+ bg-secondary: #'5865f2',
+ gray: colors.trueGray,
+ 900: '#202225',
+ 800: '#2f3136',
+ 700: '#36393f',
+ 600: '#4f545c',
+ 400: '#d4d7dc',
+ 300: '#e3e5e8',
+ 200: '#ohedef',
+ 100: ,#f2f3f5',
+ },
+ },
+ },
+ variants: {
+ extend: {},
+ },
+ plugins: [],
+}
\ No newline at end of file
diff --git a/.idx/tests.js b/.idx/tests.js
new file mode 100644
index 0000000..69fccaf
--- /dev/null
+++ b/.idx/tests.js
@@ -0,0 +1,75 @@
+'use strict';
+
+const {
+ ObjectAssign,
+ ObjectDefineProperty,
+} = primordials;
+
+const { test, suite, before, after, beforeEach, afterEach } = require('internal/test_runner/harness');
+const { run } = require('internal/test_runner/runner');
+
+module.exports = test;
+ObjectAssign(module.exports, {
+ after,
+ afterEach,
+ before,
+ beforeEach,
+ describe: suite,
+ it: test,
+ run,
+ suite,
+ test,
+});
+
+let lazyMock;
+
+ObjectDefineProperty(module.exports, 'mock', {
+ __proto__: null,
+ configurable: true,
+ enumerable: true,
+ get() {
+ if (lazyMock === undefined) {
+ const { MockTracker } = require('internal/test_runner/mock/mock');
+
+ lazyMock = new MockTracker();
+ }
+
+ return lazyMock;
+ },
+});
+
+let lazySnapshot;
+
+ObjectDefineProperty(module.exports, 'snapshot', {
+ __proto__: null,
+ configurable: true,
+ enumerable: true,
+ get() {
+ if (lazySnapshot === undefined) {
+ const {
+ setDefaultSnapshotSerializers,
+ setResolveSnapshotPath,
+ } = require('internal/test_runner/snapshot');
+
+ lazySnapshot = {
+ __proto__: null,
+ setDefaultSnapshotSerializers,
+ setResolveSnapshotPath,
+ };
+ }
+
+ return lazySnapshot;
+ },
+});
+
+ObjectDefineProperty(module.exports, 'assert', {
+ __proto__: null,
+ configurable: true,
+ enumerable: true,
+ get() {
+ const { register } = require('internal/test_runner/assert');
+ const assert = { __proto__: null, register };
+ ObjectDefineProperty(module.exports, 'assert', assert);
+ return assert;
+ },
+});
\ No newline at end of file
diff --git a/.idx/todo.jsx b/.idx/todo.jsx
new file mode 100644
index 0000000..9468316
--- /dev/null
+++ b/.idx/todo.jsx
@@ -0,0 +1,68 @@
+import { useCountTodo } from './todo.jsx/useCountTodo';
+import todoStore from './todoStore';
+export const useTodo = todoStore;
+import { create } from 'zustand';
+import { devtools } from 'zustand/middleware';
+// import { mission } from 'tasks/mission.js'
+
+const _TodoStoreInstance = create(
+ devtools((set) => ({
+ todos: 0,
+ todo: 0,
+ increasePopulation: () => set((state) => ({ todo: state.todo + 1 })),
+ removeAllTodo: () => set({ todo: 0 }),
+ updateTodo: (newTodo) => set({ todo: newTodo }),
+ }))
+);
+ function TodoCounter() {
+ const todo = useTodo((state) => state.todos);
+ return
+
+ )
+}
+
+export const Button = () => {
+ const markUncompletedTasks = () => console.log("red");
+
+ return (
+
+
+ );
+};
+
+export const Footer = () => {
+ return (
+
+ );
+};
+
+export default todoStore; // Removed the default export of useTodo to comply with Fast Refresh requirements.
\ No newline at end of file
diff --git a/.idx/todoStore.ts b/.idx/todoStore.ts
new file mode 100644
index 0000000..a991b78
--- /dev/null
+++ b/.idx/todoStore.ts
@@ -0,0 +1,34 @@
+import { create } from "zustand";
+import { TodoItem } from "./assets/stores/components/pages/TodoItem";
+export interface Todo {...
+ //Define the store's state type
+ interface Todostate {
+ todos: Todo[];
+ inSubscribed:bolean;
+ setTodos: (todos: Todo[]) => void;
+ }
+ export const useTodoStore = create()((set) => ({)
+ todos: [],
+ inSubcribed: true,
+ setTodos: (todos) => set({ todos })
+ }));
+
+ export const useTodoStore = () => useTodoStore((state)) => state.todos);
+ todos: []
+ isSubscribed: true,
+ actions: TodoActions;
+ setTodos: (todos) => set({ todos })
+ setSubscribed: () => set((old) => ){isSubscribed: !old.isSubscribed })),
+}));
+export const useTodos = () => useTodoStore((state) => state.todos);
+export const useTodo = (id: string)=>
+ useTodoStore((state) => state.todos.find((todo) => state.todos);
+export const useTodo = (id: string) =>
+ useTodoStore((state) => state.todos.find((todo) => todo.id === id));
+export const useSubscribed = () => useTodoStore((state) => state.isSubscribed);
+export const useTodos =Todostore ((state) => state.todos);
+
+export const useTodo = (id: string) =>
+ useTodoStore((state => state.todos.find((TodoItem.id ===id));
+export const useSubscribed = () useTodoStore((state) => state.isSubscribed);
+export const useTodoActions =() => useTodoStore((state) state.actions);
diff --git a/.idx/todoform.jsx b/.idx/todoform.jsx
new file mode 100644
index 0000000..9468316
--- /dev/null
+++ b/.idx/todoform.jsx
@@ -0,0 +1,68 @@
+import { useCountTodo } from './todo.jsx/useCountTodo';
+import todoStore from './todoStore';
+export const useTodo = todoStore;
+import { create } from 'zustand';
+import { devtools } from 'zustand/middleware';
+// import { mission } from 'tasks/mission.js'
+
+const _TodoStoreInstance = create(
+ devtools((set) => ({
+ todos: 0,
+ todo: 0,
+ increasePopulation: () => set((state) => ({ todo: state.todo + 1 })),
+ removeAllTodo: () => set({ todo: 0 }),
+ updateTodo: (newTodo) => set({ todo: newTodo }),
+ }))
+);
+ function TodoCounter() {
+ const todo = useTodo((state) => state.todos);
+ return
+
+ )
+}
+
+export const Button = () => {
+ const markUncompletedTasks = () => console.log("red");
+
+ return (
+
+
+ );
+};
+
+export const Footer = () => {
+ return (
+
+ );
+};
+
+export default todoStore; // Removed the default export of useTodo to comply with Fast Refresh requirements.
\ No newline at end of file
diff --git a/.idx/touch/routes/app.js b/.idx/touch/routes/app.js
new file mode 100644
index 0000000..f48ba1e
--- /dev/null
+++ b/.idx/touch/routes/app.js
@@ -0,0 +1,57 @@
+
+
+
+
+
+
+
+var logger = require('morgan');
+var session = require('express-session');
+var session = require('express-session');
+var passport = require('passport');
+
+var SQLiteStore = require('connect-sqlite3')(session);
+
+var indexRouter = require('./routes/index');
+var authRouter = require('./routes/auth');
+
+
+
+
+
+
+
+
+
+
+
+
+
+app.use(express.static(path.join(__dirname, 'public')));
+app.use(session({
+ secret: 'keyboard cat',
+ resave: false,
+ saveUninitialized: false,
+ store: new SQLiteStore({ db: 'sessions.db', dir: './var/db' })
+ app.use(session({
+ secret: 'keyboard cat',
+ resave: false,
+ saveUninitialized: false,
+ store: new SQLiteStore({ db: 'sessions.db', dir: './var/db' })
+ }));
+ app.use(passport.authenticate('session'));
+}));
+
+app.use('/', indexRouter);
+app.use('/', authRouter);
+passport.serializeUser(function(user, cb) {
+ process.nextTick(function() {
+ cb(null, { id: user.id, username: user.username, name: user.name });
+ });
+ });
+
+ passport.deserializeUser(function(user, cb) {
+ process.nextTick(function() {
+ return cb(null, user);
+ });
+ });
\ No newline at end of file
diff --git a/.idx/touch/routes/auth.js b/.idx/touch/routes/auth.js
new file mode 100644
index 0000000..f4e8191
--- /dev/null
+++ b/.idx/touch/routes/auth.js
@@ -0,0 +1,77 @@
+var express = require('express');
+var express = require('express');
+var passport = require('passport');
+var FacebookStrategy = require('passport-facebook');
+var db = require('../db');
+var router = express.Router();
+
+passport.use(new FacebookStrategy({
+ clientID: process.env['FACEBOOK_CLIENT_ID'],
+ clientSecret: process.env['FACEBOOK_CLIENT_SECRET'],
+ callbackURL: '/oauth2/redirect/facebook',
+ state: true
+ }, function verify(accessToken, refreshToken, profile, cb) {
+ db.get('SELECT * FROM federated_credentials WHERE provider = ? AND subject = ?', [
+ 'https://www.facebook.com',
+ profile.id
+ ], function(err, row) {
+ if (err) { return cb(err); }
+ if (!row) {
+ db.run('INSERT INTO users (name) VALUES (?)', [
+ profile.displayName
+ ], function(err) {
+ if (err) { return cb(err); }
+
+ var id = this.lastID;
+ db.run('INSERT INTO federated_credentials (user_id, provider, subject) VALUES (?, ?, ?)', [
+ id,
+ 'https://www.facebook.com',
+ profile.id
+ ], function(err) {
+ if (err) { return cb(err); }
+ var user = {
+ id: id,
+ name: profile.displayName
+ };
+ return cb(null, user);
+ });
+ });
+ } else {
+ db.get('SELECT * FROM users WHERE id = ?', [ row.user_id ], function(err, row) {
+ if (err) { return cb(err); }
+ if (!row) { return cb(null, false); }
+ return cb(null, row);
+ });
+ }
+ });
+ }));
+router.get('/login', function(req, res, next) {
+ res.render('login');
+});
+router.get('/login/federated/facebook', passport.authenticate('facebook'));
+module.exports = router;
+
+
+router.get('/oauth2/redirect/facebook', passport.authenticate('facebook', {
+ successRedirect: '/',
+ failureRedirect: '/login'
+ }));
+
+
+
+
+
+
+
+
+
+
+
+
+
+ router.post('/logout', function(req, res, next) {
+ req.logout(function(err) {
+ if (err) { return next(err); }
+ res.redirect('/');
+ });
+ });
\ No newline at end of file
diff --git a/.idx/touch/routes/views/login.ejs b/.idx/touch/routes/views/login.ejs
new file mode 100644
index 0000000..200208c
--- /dev/null
+++ b/.idx/touch/routes/views/login.ejs
@@ -0,0 +1,16 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+(
+ args: string[],
+ options?: SO,
+): SyncResult => {
+ return execaCommandSync(`node ${CLI_PATH} ${args.join(' ')}`, options)
+}
+
+// Helper to create a non-empty directory
+const createNonEmptyDir = (overrideFolder?: string) => {
+ // Create the temporary directory
+ const newNonEmptyFolder = overrideFolder || genPath
+ fs.mkdirSync(newNonEmptyFolder, { recursive: true })
+
+ // Create a package.json file
+ const pkgJson = path.join(newNonEmptyFolder, 'package.json')
+ fs.writeFileSync(pkgJson, '{ "foo": "bar" }')
+}
+
+// Vue 3 starter template
+const templateFiles = fs
+ .readdirSync(path.join(CLI_PATH, 'template-vue'))
+ // _gitignore is renamed to .gitignore
+ .map((filePath) => (filePath === '_gitignore' ? '.gitignore' : filePath))
+ .sort()
+
+// React starter template
+const templateFilesReact = fs
+ .readdirSync(path.join(CLI_PATH, 'template-react'))
+ // _gitignore is renamed to .gitignore
+ .map((filePath) => (filePath === '_gitignore' ? '.gitignore' : filePath))
+ .sort()
+
+const clearAnyPreviousFolders = () => {
+ if (fs.existsSync(genPath)) {
+ fs.rmSync(genPath, { recursive: true, force: true })
+ }
+ if (fs.existsSync(genPathWithSubfolder)) {
+ fs.rmSync(genPathWithSubfolder, { recursive: true, force: true })
+ }
+}
+
+beforeAll(() => clearAnyPreviousFolders())
+afterEach(() => clearAnyPreviousFolders())
+
+test('prompts for the project name if none supplied', () => {
+ const { stdout } = run([])
+ expect(stdout).toContain('Project name:')
+})
+
+test('prompts for the framework if none supplied when target dir is current directory', () => {
+ fs.mkdirSync(genPath, { recursive: true })
+ const { stdout } = run(['.'], { cwd: genPath })
+ expect(stdout).toContain('Select a framework:')
+})
+
+test('prompts for the framework if none supplied', () => {
+ const { stdout } = run([projectName])
+ expect(stdout).toContain('Select a framework:')
+})
+
+test('prompts for the framework on not supplying a value for --template', () => {
+ const { stdout } = run([projectName, '--template'])
+ expect(stdout).toContain('Select a framework:')
+})
+
+test('prompts for the framework on supplying an invalid template', () => {
+ const { stdout } = run([projectName, '--template', 'unknown'])
+ expect(stdout).toContain(
+ `"unknown" isn't a valid template. Please choose from below:`,
+ )
+})
+
+test('asks to overwrite non-empty target directory', () => {
+ createNonEmptyDir()
+ const { stdout } = run([projectName], { cwd: __dirname })
+ expect(stdout).toContain(`Target directory "${projectName}" is not empty.`)
+})
+
+test('asks to overwrite non-empty target directory with subfolder', () => {
+ createNonEmptyDir(genPathWithSubfolder)
+ const { stdout } = run([`subfolder/${projectName}`], { cwd: __dirname })
+ expect(stdout).toContain(
+ `Target directory "subfolder/${projectName}" is not empty.`,
+ )
+})
+
+test('asks to overwrite non-empty current directory', () => {
+ createNonEmptyDir()
+ const { stdout } = run(['.'], { cwd: genPath })
+ expect(stdout).toContain(`Current directory is not empty.`)
+})
+
+test('successfully scaffolds a project based on vue starter template', () => {
+ const { stdout } = run([projectName, '--template', 'vue'], {
+ cwd: __dirname,
+ })
+ const generatedFiles = fs.readdirSync(genPath).sort()
+
+ // Assertions
+ expect(stdout).toContain(`Scaffolding project in ${genPath}`)
+ expect(templateFiles).toEqual(generatedFiles)
+})
+
+test('successfully scaffolds a project with subfolder based on react starter template', () => {
+ const { stdout } = run([`subfolder/${projectName}`, '--template', 'react'], {
+ cwd: __dirname,
+ })
+ const generatedFiles = fs.readdirSync(genPathWithSubfolder).sort()
+
+ // Assertions
+ expect(stdout).toContain(`Scaffolding project in ${genPathWithSubfolder}`)
+ expect(templateFilesReact).toEqual(generatedFiles)
+})
+
+test('works with the -t alias', () => {
+ const { stdout } = run([projectName, '-t', 'vue'], {
+ cwd: __dirname,
+ })
+ const generatedFiles = fs.readdirSync(genPath).sort()
+
+ // Assertions
+ expect(stdout).toContain(`Scaffolding project in ${genPath}`)
+ expect(templateFiles).toEqual(generatedFiles)
+})
+
+test('accepts command line override for --overwrite', () => {
+ createNonEmptyDir()
+ const { stdout } = run(['.', '--overwrite', 'ignore'], { cwd: genPath })
+ expect(stdout).not.toContain(`Current directory is not empty.`)
+})
+
+test('return help usage how to use create-vite', () => {
+ const { stdout } = run(['--help'], { cwd: __dirname })
+ const message = 'Usage: create-vite [OPTION]... [DIRECTORY]'
+ expect(stdout).toContain(message)
+})
+
+test('return help usage how to use create-vite with -h alias', () => {
+ const { stdout } = run(['--h'], { cwd: __dirname })
+ const message = 'Usage: create-vite [OPTION]... [DIRECTORY]'
+ expect(stdout).toContain(message)
+})
\ No newline at end of file
diff --git a/cpython b/cpython
new file mode 160000
index 0000000..1e3d3ed
--- /dev/null
+++ b/cpython
@@ -0,0 +1 @@
+Subproject commit 1e3d3ed571bf7f507bee69aaf7ac87c42732b844
diff --git a/craco.config.js b/craco.config.js
new file mode 100644
index 0000000..880ea08
--- /dev/null
+++ b/craco.config.js
@@ -0,0 +1,11 @@
+module.exports = {
+ style: {
+ postcss: {
+ plugins: [
+ require('tailwindcss'),
+ require('autoprefixer'),
+ ],
+
+ },
+ },
+}
\ No newline at end of file
diff --git a/dist/assets/index-4gmHgof3.js b/dist/assets/index-4gmHgof3.js
new file mode 100644
index 0000000..93bc1b0
--- /dev/null
+++ b/dist/assets/index-4gmHgof3.js
@@ -0,0 +1,71 @@
+(function(){const i=document.createElement("link").relList;if(i&&i.supports&&i.supports("modulepreload"))return;for(const d of document.querySelectorAll('link[rel="modulepreload"]'))c(d);new MutationObserver(d=>{for(const s of d)if(s.type==="childList")for(const y of s.addedNodes)y.tagName==="LINK"&&y.rel==="modulepreload"&&c(y)}).observe(document,{childList:!0,subtree:!0});function f(d){const s={};return d.integrity&&(s.integrity=d.integrity),d.referrerPolicy&&(s.referrerPolicy=d.referrerPolicy),d.crossOrigin==="use-credentials"?s.credentials="include":d.crossOrigin==="anonymous"?s.credentials="omit":s.credentials="same-origin",s}function c(d){if(d.ep)return;d.ep=!0;const s=f(d);fetch(d.href,s)}})();var Si=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{};function ao(u){return u&&u.__esModule&&Object.prototype.hasOwnProperty.call(u,"default")?u.default:u}var Bf={exports:{}},ar={};/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var Zh;function fg(){if(Zh)return ar;Zh=1;var u=Symbol.for("react.transitional.element"),i=Symbol.for("react.fragment");function f(c,d,s){var y=null;if(s!==void 0&&(y=""+s),d.key!==void 0&&(y=""+d.key),"key"in d){s={};for(var p in d)p!=="key"&&(s[p]=d[p])}else s=d;return d=s.ref,{$$typeof:u,type:c,key:y,ref:d!==void 0?d:null,props:s}}return ar.Fragment=i,ar.jsx=f,ar.jsxs=f,ar}var Kh;function og(){return Kh||(Kh=1,Bf.exports=fg()),Bf.exports}var fe=og(),jf={exports:{}},je={};/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var Jh;function sg(){if(Jh)return je;Jh=1;var u=Symbol.for("react.transitional.element"),i=Symbol.for("react.portal"),f=Symbol.for("react.fragment"),c=Symbol.for("react.strict_mode"),d=Symbol.for("react.profiler"),s=Symbol.for("react.consumer"),y=Symbol.for("react.context"),p=Symbol.for("react.forward_ref"),g=Symbol.for("react.suspense"),v=Symbol.for("react.memo"),E=Symbol.for("react.lazy"),S=Symbol.iterator;function D(A){return A===null||typeof A!="object"?null:(A=S&&A[S]||A["@@iterator"],typeof A=="function"?A:null)}var w={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},x=Object.assign,Z={};function Y(A,K,ce){this.props=A,this.context=K,this.refs=Z,this.updater=ce||w}Y.prototype.isReactComponent={},Y.prototype.setState=function(A,K){if(typeof A!="object"&&typeof A!="function"&&A!=null)throw Error("takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,A,K,"setState")},Y.prototype.forceUpdate=function(A){this.updater.enqueueForceUpdate(this,A,"forceUpdate")};function W(){}W.prototype=Y.prototype;function I(A,K,ce){this.props=A,this.context=K,this.refs=Z,this.updater=ce||w}var oe=I.prototype=new W;oe.constructor=I,x(oe,Y.prototype),oe.isPureReactComponent=!0;var Ce=Array.isArray,V={H:null,A:null,T:null,S:null,V:null},C=Object.prototype.hasOwnProperty;function ue(A,K,ce,ie,Ee,Ye){return ce=Ye.ref,{$$typeof:u,type:A,key:K,ref:ce!==void 0?ce:null,props:Ye}}function se(A,K){return ue(A.type,K,void 0,void 0,void 0,A.props)}function ye(A){return typeof A=="object"&&A!==null&&A.$$typeof===u}function ze(A){var K={"=":"=0",":":"=2"};return"$"+A.replace(/[=:]/g,function(ce){return K[ce]})}var Ke=/\/+/g;function Xe(A,K){return typeof A=="object"&&A!==null&&A.key!=null?ze(""+A.key):K.toString(36)}function Le(){}function Qe(A){switch(A.status){case"fulfilled":return A.value;case"rejected":throw A.reason;default:switch(typeof A.status=="string"?A.then(Le,Le):(A.status="pending",A.then(function(K){A.status==="pending"&&(A.status="fulfilled",A.value=K)},function(K){A.status==="pending"&&(A.status="rejected",A.reason=K)})),A.status){case"fulfilled":return A.value;case"rejected":throw A.reason}}throw A}function Je(A,K,ce,ie,Ee){var Ye=typeof A;(Ye==="undefined"||Ye==="boolean")&&(A=null);var _e=!1;if(A===null)_e=!0;else switch(Ye){case"bigint":case"string":case"number":_e=!0;break;case"object":switch(A.$$typeof){case u:case i:_e=!0;break;case E:return _e=A._init,Je(_e(A._payload),K,ce,ie,Ee)}}if(_e)return Ee=Ee(A),_e=ie===""?"."+Xe(A,0):ie,Ce(Ee)?(ce="",_e!=null&&(ce=_e.replace(Ke,"$&/")+"/"),Je(Ee,K,ce,"",function(va){return va})):Ee!=null&&(ye(Ee)&&(Ee=se(Ee,ce+(Ee.key==null||A&&A.key===Ee.key?"":(""+Ee.key).replace(Ke,"$&/")+"/")+_e)),K.push(Ee)),1;_e=0;var Ut=ie===""?".":ie+":";if(Ce(A))for(var nt=0;nt>>1,A=j[Be];if(0>>1;Bed(ie,de))Eed(Ye,ie)?(j[Be]=Ye,j[Ee]=de,Be=Ee):(j[Be]=ie,j[ce]=de,Be=ce);else if(Eed(Ye,de))j[Be]=Ye,j[Ee]=de,Be=Ee;else break e}}return le}function d(j,le){var de=j.sortIndex-le.sortIndex;return de!==0?de:j.id-le.id}if(u.unstable_now=void 0,typeof performance=="object"&&typeof performance.now=="function"){var s=performance;u.unstable_now=function(){return s.now()}}else{var y=Date,p=y.now();u.unstable_now=function(){return y.now()-p}}var g=[],v=[],E=1,S=null,D=3,w=!1,x=!1,Z=!1,Y=!1,W=typeof setTimeout=="function"?setTimeout:null,I=typeof clearTimeout=="function"?clearTimeout:null,oe=typeof setImmediate<"u"?setImmediate:null;function Ce(j){for(var le=f(v);le!==null;){if(le.callback===null)c(v);else if(le.startTime<=j)c(v),le.sortIndex=le.expirationTime,i(g,le);else break;le=f(v)}}function V(j){if(Z=!1,Ce(j),!x)if(f(g)!==null)x=!0,C||(C=!0,Xe());else{var le=f(v);le!==null&&Je(V,le.startTime-j)}}var C=!1,ue=-1,se=5,ye=-1;function ze(){return Y?!0:!(u.unstable_now()-yej&&ze());){var Be=S.callback;if(typeof Be=="function"){S.callback=null,D=S.priorityLevel;var A=Be(S.expirationTime<=j);if(j=u.unstable_now(),typeof A=="function"){S.callback=A,Ce(j),le=!0;break t}S===f(g)&&c(g),Ce(j)}else c(g);S=f(g)}if(S!==null)le=!0;else{var K=f(v);K!==null&&Je(V,K.startTime-j),le=!1}}break e}finally{S=null,D=de,w=!1}le=void 0}}finally{le?Xe():C=!1}}}var Xe;if(typeof oe=="function")Xe=function(){oe(Ke)};else if(typeof MessageChannel<"u"){var Le=new MessageChannel,Qe=Le.port2;Le.port1.onmessage=Ke,Xe=function(){Qe.postMessage(null)}}else Xe=function(){W(Ke,0)};function Je(j,le){ue=W(function(){j(u.unstable_now())},le)}u.unstable_IdlePriority=5,u.unstable_ImmediatePriority=1,u.unstable_LowPriority=4,u.unstable_NormalPriority=3,u.unstable_Profiling=null,u.unstable_UserBlockingPriority=2,u.unstable_cancelCallback=function(j){j.callback=null},u.unstable_forceFrameRate=function(j){0>j||125Be?(j.sortIndex=de,i(v,j),f(g)===null&&j===f(v)&&(Z?(I(ue),ue=-1):Z=!0,Je(V,de-Be))):(j.sortIndex=A,i(g,j),x||w||(x=!0,C||(C=!0,Xe()))),j},u.unstable_shouldYield=ze,u.unstable_wrapCallback=function(j){var le=D;return function(){var de=D;D=le;try{return j.apply(this,arguments)}finally{D=de}}}})(Gf)),Gf}var Wh;function hg(){return Wh||(Wh=1,qf.exports=dg()),qf.exports}var Xf={exports:{}},Xt={};/**
+ * @license React
+ * react-dom.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var kh;function vg(){if(kh)return Xt;kh=1;var u=no();function i(g){var v="https://react.dev/errors/"+g;if(1"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(u)}catch(i){console.error(i)}}return u(),Xf.exports=vg(),Xf.exports}/**
+ * @license React
+ * react-dom-client.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var Ih;function mg(){if(Ih)return nr;Ih=1;var u=hg(),i=no(),f=wv();function c(e){var t="https://react.dev/errors/"+e;if(1A||(e.current=Be[A],Be[A]=null,A--)}function ie(e,t){A++,Be[A]=e.current,e.current=t}var Ee=K(null),Ye=K(null),_e=K(null),Ut=K(null);function nt(e,t){switch(ie(_e,t),ie(Ye,e),ie(Ee,null),t.nodeType){case 9:case 11:e=(e=t.documentElement)&&(e=e.namespaceURI)?bh(e):0;break;default:if(e=t.tagName,t=t.namespaceURI)t=bh(t),e=Sh(t,e);else switch(e){case"svg":e=1;break;case"math":e=2;break;default:e=0}}ce(Ee),ie(Ee,e)}function va(){ce(Ee),ce(Ye),ce(_e)}function pt(e){e.memoizedState!==null&&ie(Ut,e);var t=Ee.current,a=Sh(t,e.type);t!==a&&(ie(Ye,e),ie(Ee,a))}function aa(e){Ye.current===e&&(ce(Ee),ce(Ye)),Ut.current===e&&(ce(Ut),ku._currentValue=de)}var vn=Object.prototype.hasOwnProperty,Fn=u.unstable_scheduleCallback,na=u.unstable_cancelCallback,ma=u.unstable_shouldYield,uu=u.unstable_requestPaint,jt=u.unstable_now,mn=u.unstable_getCurrentPriorityLevel,yn=u.unstable_ImmediatePriority,gn=u.unstable_UserBlockingPriority,Ba=u.unstable_NormalPriority,ya=u.unstable_LowPriority,Oa=u.unstable_IdlePriority,Wn=u.log,pn=u.unstable_setDisableYieldValue,Nt=null,ot=null;function Jt(e){if(typeof Wn=="function"&&pn(e),ot&&typeof ot.setStrictMode=="function")try{ot.setStrictMode(Nt,e)}catch{}}var Tt=Math.clz32?Math.clz32:kn,Al=Math.log,la=Math.LN2;function kn(e){return e>>>=0,e===0?32:31-(Al(e)/la|0)|0}var ja=256,Ma=4194304;function za(e){var t=e&42;if(t!==0)return t;switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;case 128:return 128;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return e&4194048;case 4194304:case 8388608:case 16777216:case 33554432:return e&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return e}}function Ja(e,t,a){var n=e.pendingLanes;if(n===0)return 0;var l=0,r=e.suspendedLanes,o=e.pingedLanes;e=e.warmLanes;var h=n&134217727;return h!==0?(n=h&~r,n!==0?l=za(n):(o&=h,o!==0?l=za(o):a||(a=h&~e,a!==0&&(l=za(a))))):(h=n&~r,h!==0?l=za(h):o!==0?l=za(o):a||(a=n&~e,a!==0&&(l=za(a)))),l===0?0:t!==0&&t!==l&&(t&r)===0&&(r=l&-l,a=t&-t,r>=a||r===32&&(a&4194048)!==0)?t:l}function $t(e,t){return(e.pendingLanes&~(e.suspendedLanes&~e.pingedLanes)&t)===0}function Pn(e,t){switch(e){case 1:case 2:case 4:case 8:case 64:return t+250;case 16:case 32:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return t+5e3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function bn(){var e=ja;return ja<<=1,(ja&4194048)===0&&(ja=256),e}function ua(){var e=Ma;return Ma<<=1,(Ma&62914560)===0&&(Ma=4194304),e}function Sn(e){for(var t=[],a=0;31>a;a++)t.push(e);return t}function $a(e,t){e.pendingLanes|=t,t!==268435456&&(e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0)}function In(e,t,a,n,l,r){var o=e.pendingLanes;e.pendingLanes=a,e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0,e.expiredLanes&=a,e.entangledLanes&=a,e.errorRecoveryDisabledLanes&=a,e.shellSuspendCounter=0;var h=e.entanglements,R=e.expirationTimes,B=e.hiddenUpdates;for(a=o&~a;0)":-1l||R[n]!==B[l]){var J=`
+`+R[n].replace(" at new "," at ");return e.displayName&&J.includes("")&&(J=J.replace("",e.displayName)),J}while(1<=n&&0<=l);break}}}finally{it=!1,Error.prepareStackTrace=a}return(a=e?e.displayName||e.name:"")?qt(a):""}function _l(e){switch(e.tag){case 26:case 27:case 5:return qt(e.type);case 16:return qt("Lazy");case 13:return qt("Suspense");case 19:return qt("SuspenseList");case 0:case 15:return Ya(e.type,!1);case 11:return Ya(e.type.render,!1);case 1:return Ya(e.type,!0);case 31:return qt("Activity");default:return""}}function m(e){try{var t="";do t+=_l(e),e=e.return;while(e);return t}catch(a){return`
+Error generating stack: `+a.message+`
+`+a.stack}}function T(e){switch(typeof e){case"bigint":case"boolean":case"number":case"string":case"undefined":return e;case"object":return e;default:return""}}function b(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()==="input"&&(t==="checkbox"||t==="radio")}function z(e){var t=b(e)?"checked":"value",a=Object.getOwnPropertyDescriptor(e.constructor.prototype,t),n=""+e[t];if(!e.hasOwnProperty(t)&&typeof a<"u"&&typeof a.get=="function"&&typeof a.set=="function"){var l=a.get,r=a.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return l.call(this)},set:function(o){n=""+o,r.call(this,o)}}),Object.defineProperty(e,t,{enumerable:a.enumerable}),{getValue:function(){return n},setValue:function(o){n=""+o},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function N(e){e._valueTracker||(e._valueTracker=z(e))}function M(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var a=t.getValue(),n="";return e&&(n=b(e)?e.checked?"true":"false":e.value),e=n,e!==a?(t.setValue(e),!0):!1}function $(e){if(e=e||(typeof document<"u"?document:void 0),typeof e>"u")return null;try{return e.activeElement||e.body}catch{return e.body}}var te=/[\n"\\]/g;function ee(e){return e.replace(te,function(t){return"\\"+t.charCodeAt(0).toString(16)+" "})}function ne(e,t,a,n,l,r,o,h){e.name="",o!=null&&typeof o!="function"&&typeof o!="symbol"&&typeof o!="boolean"?e.type=o:e.removeAttribute("type"),t!=null?o==="number"?(t===0&&e.value===""||e.value!=t)&&(e.value=""+T(t)):e.value!==""+T(t)&&(e.value=""+T(t)):o!=="submit"&&o!=="reset"||e.removeAttribute("value"),t!=null?ve(e,o,T(t)):a!=null?ve(e,o,T(a)):n!=null&&e.removeAttribute("value"),l==null&&r!=null&&(e.defaultChecked=!!r),l!=null&&(e.checked=l&&typeof l!="function"&&typeof l!="symbol"),h!=null&&typeof h!="function"&&typeof h!="symbol"&&typeof h!="boolean"?e.name=""+T(h):e.removeAttribute("name")}function re(e,t,a,n,l,r,o,h){if(r!=null&&typeof r!="function"&&typeof r!="symbol"&&typeof r!="boolean"&&(e.type=r),t!=null||a!=null){if(!(r!=="submit"&&r!=="reset"||t!=null))return;a=a!=null?""+T(a):"",t=t!=null?""+T(t):a,h||t===e.value||(e.value=t),e.defaultValue=t}n=n??l,n=typeof n!="function"&&typeof n!="symbol"&&!!n,e.checked=h?e.checked:!!n,e.defaultChecked=!!n,o!=null&&typeof o!="function"&&typeof o!="symbol"&&typeof o!="boolean"&&(e.name=o)}function ve(e,t,a){t==="number"&&$(e.ownerDocument)===e||e.defaultValue===""+a||(e.defaultValue=""+a)}function we(e,t,a,n){if(e=e.options,t){t={};for(var l=0;l"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),Yi=!1;if(Ia)try{var su={};Object.defineProperty(su,"passive",{get:function(){Yi=!0}}),window.addEventListener("test",su,su),window.removeEventListener("test",su,su)}catch{Yi=!1}var Rn=null,qi=null,mr=null;function To(){if(mr)return mr;var e,t=qi,a=t.length,n,l="value"in Rn?Rn.value:Rn.textContent,r=l.length;for(e=0;e=vu),Mo=" ",zo=!1;function wo(e,t){switch(e){case"keyup":return Nm.indexOf(t.keyCode)!==-1;case"keydown":return t.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function Uo(e){return e=e.detail,typeof e=="object"&&"data"in e?e.data:null}var xl=!1;function Lm(e,t){switch(e){case"compositionend":return Uo(t);case"keypress":return t.which!==32?null:(zo=!0,Mo);case"textInput":return e=t.data,e===Mo&&zo?null:e;default:return null}}function Hm(e,t){if(xl)return e==="compositionend"||!Zi&&wo(e,t)?(e=To(),mr=qi=Rn=null,xl=!1,e):null;switch(e){case"paste":return null;case"keypress":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1=t)return{node:a,offset:t-e};e=n}e:{for(;a;){if(a.nextSibling){a=a.nextSibling;break e}a=a.parentNode}a=void 0}a=qo(a)}}function Xo(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?Xo(e,t.parentNode):"contains"in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function Qo(e){e=e!=null&&e.ownerDocument!=null&&e.ownerDocument.defaultView!=null?e.ownerDocument.defaultView:window;for(var t=$(e.document);t instanceof e.HTMLIFrameElement;){try{var a=typeof t.contentWindow.location.href=="string"}catch{a=!1}if(a)e=t.contentWindow;else break;t=$(e.document)}return t}function $i(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t==="input"&&(e.type==="text"||e.type==="search"||e.type==="tel"||e.type==="url"||e.type==="password")||t==="textarea"||e.contentEditable==="true")}var Vm=Ia&&"documentMode"in document&&11>=document.documentMode,Ol=null,Fi=null,pu=null,Wi=!1;function Vo(e,t,a){var n=a.window===a?a.document:a.nodeType===9?a:a.ownerDocument;Wi||Ol==null||Ol!==$(n)||(n=Ol,"selectionStart"in n&&$i(n)?n={start:n.selectionStart,end:n.selectionEnd}:(n=(n.ownerDocument&&n.ownerDocument.defaultView||window).getSelection(),n={anchorNode:n.anchorNode,anchorOffset:n.anchorOffset,focusNode:n.focusNode,focusOffset:n.focusOffset}),pu&&gu(pu,n)||(pu=n,n=ui(Fi,"onSelect"),0>=o,l-=o,tn=1<<32-Tt(t)+l|a<r?r:8;var o=j.T,h={};j.T=h,Lc(e,!1,t,a);try{var R=l(),B=j.S;if(B!==null&&B(h,R),R!==null&&typeof R=="object"&&typeof R.then=="function"){var J=Im(R,n);Nu(e,t,J,sa(e))}else Nu(e,t,n,sa(e))}catch(k){Nu(e,t,{then:function(){},status:"rejected",reason:k},sa())}finally{le.p=r,j.T=o}}function ly(){}function Nc(e,t,a,n){if(e.tag!==5)throw Error(c(476));var l=Zs(e).queue;Vs(e,l,t,de,a===null?ly:function(){return Ks(e),a(n)})}function Zs(e){var t=e.memoizedState;if(t!==null)return t;t={memoizedState:de,baseState:de,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:un,lastRenderedState:de},next:null};var a={};return t.next={memoizedState:a,baseState:a,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:un,lastRenderedState:a},next:null},e.memoizedState=t,e=e.alternate,e!==null&&(e.memoizedState=t),t}function Ks(e){var t=Zs(e).next.queue;Nu(e,t,{},sa())}function Cc(){return Gt(ku)}function Js(){return _t().memoizedState}function $s(){return _t().memoizedState}function uy(e){for(var t=e.return;t!==null;){switch(t.tag){case 24:case 3:var a=sa();e=_n(a);var n=Dn(t,e,a);n!==null&&(da(n,t,a),xu(n,t,a)),t={cache:oc()},e.payload=t;return}t=t.return}}function ry(e,t,a){var n=sa();a={lane:n,revertLane:0,action:a,hasEagerState:!1,eagerState:null,next:null},Yr(e)?Ws(t,a):(a=ec(e,t,a,n),a!==null&&(da(a,e,n),ks(a,t,n)))}function Fs(e,t,a){var n=sa();Nu(e,t,a,n)}function Nu(e,t,a,n){var l={lane:n,revertLane:0,action:a,hasEagerState:!1,eagerState:null,next:null};if(Yr(e))Ws(t,l);else{var r=e.alternate;if(e.lanes===0&&(r===null||r.lanes===0)&&(r=t.lastRenderedReducer,r!==null))try{var o=t.lastRenderedState,h=r(o,a);if(l.hasEagerState=!0,l.eagerState=h,ra(h,o))return Rr(e,t,l,0),dt===null&&Er(),!1}catch{}finally{}if(a=ec(e,t,l,n),a!==null)return da(a,e,n),ks(a,t,n),!0}return!1}function Lc(e,t,a,n){if(n={lane:2,revertLane:vf(),action:n,hasEagerState:!1,eagerState:null,next:null},Yr(e)){if(t)throw Error(c(479))}else t=ec(e,a,n,2),t!==null&&da(t,e,2)}function Yr(e){var t=e.alternate;return e===qe||t!==null&&t===qe}function Ws(e,t){jl=Nr=!0;var a=e.pending;a===null?t.next=t:(t.next=a.next,a.next=t),e.pending=t}function ks(e,t,a){if((a&4194048)!==0){var n=t.lanes;n&=e.pendingLanes,a|=n,t.lanes=a,Wa(e,a)}}var qr={readContext:Gt,use:Lr,useCallback:Et,useContext:Et,useEffect:Et,useImperativeHandle:Et,useLayoutEffect:Et,useInsertionEffect:Et,useMemo:Et,useReducer:Et,useRef:Et,useState:Et,useDebugValue:Et,useDeferredValue:Et,useTransition:Et,useSyncExternalStore:Et,useId:Et,useHostTransitionStatus:Et,useFormState:Et,useActionState:Et,useOptimistic:Et,useMemoCache:Et,useCacheRefresh:Et},Ps={readContext:Gt,use:Lr,useCallback:function(e,t){return Pt().memoizedState=[e,t===void 0?null:t],e},useContext:Gt,useEffect:Ls,useImperativeHandle:function(e,t,a){a=a!=null?a.concat([e]):null,jr(4194308,4,Ys.bind(null,t,e),a)},useLayoutEffect:function(e,t){return jr(4194308,4,e,t)},useInsertionEffect:function(e,t){jr(4,2,e,t)},useMemo:function(e,t){var a=Pt();t=t===void 0?null:t;var n=e();if(vl){Jt(!0);try{e()}finally{Jt(!1)}}return a.memoizedState=[n,t],n},useReducer:function(e,t,a){var n=Pt();if(a!==void 0){var l=a(t);if(vl){Jt(!0);try{a(t)}finally{Jt(!1)}}}else l=t;return n.memoizedState=n.baseState=l,e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:l},n.queue=e,e=e.dispatch=ry.bind(null,qe,e),[n.memoizedState,e]},useRef:function(e){var t=Pt();return e={current:e},t.memoizedState=e},useState:function(e){e=Mc(e);var t=e.queue,a=Fs.bind(null,qe,t);return t.dispatch=a,[e.memoizedState,a]},useDebugValue:wc,useDeferredValue:function(e,t){var a=Pt();return Uc(a,e,t)},useTransition:function(){var e=Mc(!1);return e=Vs.bind(null,qe,e.queue,!0,!1),Pt().memoizedState=e,[!1,e]},useSyncExternalStore:function(e,t,a){var n=qe,l=Pt();if(Ie){if(a===void 0)throw Error(c(407));a=a()}else{if(a=t(),dt===null)throw Error(c(349));($e&124)!==0||bs(n,t,a)}l.memoizedState=a;var r={value:a,getSnapshot:t};return l.queue=r,Ls(Es.bind(null,n,r,e),[e]),n.flags|=2048,ql(9,Br(),Ss.bind(null,n,r,a,t),null),a},useId:function(){var e=Pt(),t=dt.identifierPrefix;if(Ie){var a=an,n=tn;a=(n&~(1<<32-Tt(n)-1)).toString(32)+a,t="«"+t+"R"+a,a=Cr++,0xe?(wt=Te,Te=null):wt=Te.sibling;var Pe=q(U,Te,H[xe],F);if(Pe===null){Te===null&&(Te=wt);break}e&&Te&&Pe.alternate===null&&t(U,Te),O=r(Pe,O,xe),Ge===null?me=Pe:Ge.sibling=Pe,Ge=Pe,Te=wt}if(xe===H.length)return a(U,Te),Ie&&cl(U,xe),me;if(Te===null){for(;xexe?(wt=Te,Te=null):wt=Te.sibling;var Qn=q(U,Te,Pe.value,F);if(Qn===null){Te===null&&(Te=wt);break}e&&Te&&Qn.alternate===null&&t(U,Te),O=r(Qn,O,xe),Ge===null?me=Qn:Ge.sibling=Qn,Ge=Qn,Te=wt}if(Pe.done)return a(U,Te),Ie&&cl(U,xe),me;if(Te===null){for(;!Pe.done;xe++,Pe=H.next())Pe=k(U,Pe.value,F),Pe!==null&&(O=r(Pe,O,xe),Ge===null?me=Pe:Ge.sibling=Pe,Ge=Pe);return Ie&&cl(U,xe),me}for(Te=n(Te);!Pe.done;xe++,Pe=H.next())Pe=G(Te,U,xe,Pe.value,F),Pe!==null&&(e&&Pe.alternate!==null&&Te.delete(Pe.key===null?xe:Pe.key),O=r(Pe,O,xe),Ge===null?me=Pe:Ge.sibling=Pe,Ge=Pe);return e&&Te.forEach(function(cg){return t(U,cg)}),Ie&&cl(U,xe),me}function rt(U,O,H,F){if(typeof H=="object"&&H!==null&&H.type===x&&H.key===null&&(H=H.props.children),typeof H=="object"&&H!==null){switch(H.$$typeof){case D:e:{for(var me=H.key;O!==null;){if(O.key===me){if(me=H.type,me===x){if(O.tag===7){a(U,O.sibling),F=l(O,H.props.children),F.return=U,U=F;break e}}else if(O.elementType===me||typeof me=="object"&&me!==null&&me.$$typeof===se&&ed(me)===O.type){a(U,O.sibling),F=l(O,H.props),Lu(F,H),F.return=U,U=F;break e}a(U,O);break}else t(U,O);O=O.sibling}H.type===x?(F=rl(H.props.children,U.mode,F,H.key),F.return=U,U=F):(F=Ar(H.type,H.key,H.props,null,U.mode,F),Lu(F,H),F.return=U,U=F)}return o(U);case w:e:{for(me=H.key;O!==null;){if(O.key===me)if(O.tag===4&&O.stateNode.containerInfo===H.containerInfo&&O.stateNode.implementation===H.implementation){a(U,O.sibling),F=l(O,H.children||[]),F.return=U,U=F;break e}else{a(U,O);break}else t(U,O);O=O.sibling}F=nc(H,U.mode,F),F.return=U,U=F}return o(U);case se:return me=H._init,H=me(H._payload),rt(U,O,H,F)}if(Je(H))return Oe(U,O,H,F);if(Xe(H)){if(me=Xe(H),typeof me!="function")throw Error(c(150));return H=me.call(H),De(U,O,H,F)}if(typeof H.then=="function")return rt(U,O,Gr(H),F);if(H.$$typeof===oe)return rt(U,O,Or(U,H),F);Xr(U,H)}return typeof H=="string"&&H!==""||typeof H=="number"||typeof H=="bigint"?(H=""+H,O!==null&&O.tag===6?(a(U,O.sibling),F=l(O,H),F.return=U,U=F):(a(U,O),F=ac(H,U.mode,F),F.return=U,U=F),o(U)):a(U,O)}return function(U,O,H,F){try{Cu=0;var me=rt(U,O,H,F);return Gl=null,me}catch(Te){if(Te===_u||Te===zr)throw Te;var Ge=ia(29,Te,null,U.mode);return Ge.lanes=F,Ge.return=U,Ge}finally{}}}var Xl=td(!0),ad=td(!1),Ta=K(null),Ga=null;function On(e){var t=e.alternate;ie(Ot,Ot.current&1),ie(Ta,e),Ga===null&&(t===null||Bl.current!==null||t.memoizedState!==null)&&(Ga=e)}function nd(e){if(e.tag===22){if(ie(Ot,Ot.current),ie(Ta,e),Ga===null){var t=e.alternate;t!==null&&t.memoizedState!==null&&(Ga=e)}}else Mn()}function Mn(){ie(Ot,Ot.current),ie(Ta,Ta.current)}function rn(e){ce(Ta),Ga===e&&(Ga=null),ce(Ot)}var Ot=K(0);function Qr(e){for(var t=e;t!==null;){if(t.tag===13){var a=t.memoizedState;if(a!==null&&(a=a.dehydrated,a===null||a.data==="$?"||Df(a)))return t}else if(t.tag===19&&t.memoizedProps.revealOrder!==void 0){if((t.flags&128)!==0)return t}else if(t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return null;t=t.return}t.sibling.return=t.return,t=t.sibling}return null}function Hc(e,t,a,n){t=e.memoizedState,a=a(n,t),a=a==null?t:E({},t,a),e.memoizedState=a,e.lanes===0&&(e.updateQueue.baseState=a)}var Bc={enqueueSetState:function(e,t,a){e=e._reactInternals;var n=sa(),l=_n(n);l.payload=t,a!=null&&(l.callback=a),t=Dn(e,l,n),t!==null&&(da(t,e,n),xu(t,e,n))},enqueueReplaceState:function(e,t,a){e=e._reactInternals;var n=sa(),l=_n(n);l.tag=1,l.payload=t,a!=null&&(l.callback=a),t=Dn(e,l,n),t!==null&&(da(t,e,n),xu(t,e,n))},enqueueForceUpdate:function(e,t){e=e._reactInternals;var a=sa(),n=_n(a);n.tag=2,t!=null&&(n.callback=t),t=Dn(e,n,a),t!==null&&(da(t,e,a),xu(t,e,a))}};function ld(e,t,a,n,l,r,o){return e=e.stateNode,typeof e.shouldComponentUpdate=="function"?e.shouldComponentUpdate(n,r,o):t.prototype&&t.prototype.isPureReactComponent?!gu(a,n)||!gu(l,r):!0}function ud(e,t,a,n){e=t.state,typeof t.componentWillReceiveProps=="function"&&t.componentWillReceiveProps(a,n),typeof t.UNSAFE_componentWillReceiveProps=="function"&&t.UNSAFE_componentWillReceiveProps(a,n),t.state!==e&&Bc.enqueueReplaceState(t,t.state,null)}function ml(e,t){var a=t;if("ref"in t){a={};for(var n in t)n!=="ref"&&(a[n]=t[n])}if(e=e.defaultProps){a===t&&(a=E({},a));for(var l in e)a[l]===void 0&&(a[l]=e[l])}return a}var Vr=typeof reportError=="function"?reportError:function(e){if(typeof window=="object"&&typeof window.ErrorEvent=="function"){var t=new window.ErrorEvent("error",{bubbles:!0,cancelable:!0,message:typeof e=="object"&&e!==null&&typeof e.message=="string"?String(e.message):String(e),error:e});if(!window.dispatchEvent(t))return}else if(typeof process=="object"&&typeof process.emit=="function"){process.emit("uncaughtException",e);return}console.error(e)};function rd(e){Vr(e)}function id(e){console.error(e)}function cd(e){Vr(e)}function Zr(e,t){try{var a=e.onUncaughtError;a(t.value,{componentStack:t.stack})}catch(n){setTimeout(function(){throw n})}}function fd(e,t,a){try{var n=e.onCaughtError;n(a.value,{componentStack:a.stack,errorBoundary:t.tag===1?t.stateNode:null})}catch(l){setTimeout(function(){throw l})}}function jc(e,t,a){return a=_n(a),a.tag=3,a.payload={element:null},a.callback=function(){Zr(e,t)},a}function od(e){return e=_n(e),e.tag=3,e}function sd(e,t,a,n){var l=a.type.getDerivedStateFromError;if(typeof l=="function"){var r=n.value;e.payload=function(){return l(r)},e.callback=function(){fd(t,a,n)}}var o=a.stateNode;o!==null&&typeof o.componentDidCatch=="function"&&(e.callback=function(){fd(t,a,n),typeof l!="function"&&(Ln===null?Ln=new Set([this]):Ln.add(this));var h=n.stack;this.componentDidCatch(n.value,{componentStack:h!==null?h:""})})}function cy(e,t,a,n,l){if(a.flags|=32768,n!==null&&typeof n=="object"&&typeof n.then=="function"){if(t=a.alternate,t!==null&&Ru(t,a,l,!0),a=Ta.current,a!==null){switch(a.tag){case 13:return Ga===null?ff():a.alternate===null&&St===0&&(St=3),a.flags&=-257,a.flags|=65536,a.lanes=l,n===hc?a.flags|=16384:(t=a.updateQueue,t===null?a.updateQueue=new Set([n]):t.add(n),sf(e,n,l)),!1;case 22:return a.flags|=65536,n===hc?a.flags|=16384:(t=a.updateQueue,t===null?(t={transitions:null,markerInstances:null,retryQueue:new Set([n])},a.updateQueue=t):(a=t.retryQueue,a===null?t.retryQueue=new Set([n]):a.add(n)),sf(e,n,l)),!1}throw Error(c(435,a.tag))}return sf(e,n,l),ff(),!1}if(Ie)return t=Ta.current,t!==null?((t.flags&65536)===0&&(t.flags|=256),t.flags|=65536,t.lanes=l,n!==rc&&(e=Error(c(422),{cause:n}),Eu(ba(e,a)))):(n!==rc&&(t=Error(c(423),{cause:n}),Eu(ba(t,a))),e=e.current.alternate,e.flags|=65536,l&=-l,e.lanes|=l,n=ba(n,a),l=jc(e.stateNode,n,l),yc(e,l),St!==4&&(St=2)),!1;var r=Error(c(520),{cause:n});if(r=ba(r,a),Xu===null?Xu=[r]:Xu.push(r),St!==4&&(St=2),t===null)return!0;n=ba(n,a),a=t;do{switch(a.tag){case 3:return a.flags|=65536,e=l&-l,a.lanes|=e,e=jc(a.stateNode,n,e),yc(a,e),!1;case 1:if(t=a.type,r=a.stateNode,(a.flags&128)===0&&(typeof t.getDerivedStateFromError=="function"||r!==null&&typeof r.componentDidCatch=="function"&&(Ln===null||!Ln.has(r))))return a.flags|=65536,l&=-l,a.lanes|=l,l=od(l),sd(l,e,a,n),yc(a,l),!1}a=a.return}while(a!==null);return!1}var dd=Error(c(461)),Mt=!1;function Lt(e,t,a,n){t.child=e===null?ad(t,null,a,n):Xl(t,e.child,a,n)}function hd(e,t,a,n,l){a=a.render;var r=t.ref;if("ref"in n){var o={};for(var h in n)h!=="ref"&&(o[h]=n[h])}else o=n;return dl(t),n=Ec(e,t,a,o,r,l),h=Rc(),e!==null&&!Mt?(Tc(e,t,l),cn(e,t,l)):(Ie&&h&&lc(t),t.flags|=1,Lt(e,t,n,l),t.child)}function vd(e,t,a,n,l){if(e===null){var r=a.type;return typeof r=="function"&&!tc(r)&&r.defaultProps===void 0&&a.compare===null?(t.tag=15,t.type=r,md(e,t,r,n,l)):(e=Ar(a.type,null,n,t,t.mode,l),e.ref=t.ref,e.return=t,t.child=e)}if(r=e.child,!Kc(e,l)){var o=r.memoizedProps;if(a=a.compare,a=a!==null?a:gu,a(o,n)&&e.ref===t.ref)return cn(e,t,l)}return t.flags|=1,e=en(r,n),e.ref=t.ref,e.return=t,t.child=e}function md(e,t,a,n,l){if(e!==null){var r=e.memoizedProps;if(gu(r,n)&&e.ref===t.ref)if(Mt=!1,t.pendingProps=n=r,Kc(e,l))(e.flags&131072)!==0&&(Mt=!0);else return t.lanes=e.lanes,cn(e,t,l)}return Yc(e,t,a,n,l)}function yd(e,t,a){var n=t.pendingProps,l=n.children,r=e!==null?e.memoizedState:null;if(n.mode==="hidden"){if((t.flags&128)!==0){if(n=r!==null?r.baseLanes|a:a,e!==null){for(l=t.child=e.child,r=0;l!==null;)r=r|l.lanes|l.childLanes,l=l.sibling;t.childLanes=r&~n}else t.childLanes=0,t.child=null;return gd(e,t,n,a)}if((a&536870912)!==0)t.memoizedState={baseLanes:0,cachePool:null},e!==null&&Mr(t,r!==null?r.cachePool:null),r!==null?ms(t,r):pc(),nd(t);else return t.lanes=t.childLanes=536870912,gd(e,t,r!==null?r.baseLanes|a:a,a)}else r!==null?(Mr(t,r.cachePool),ms(t,r),Mn(),t.memoizedState=null):(e!==null&&Mr(t,null),pc(),Mn());return Lt(e,t,l,a),t.child}function gd(e,t,a,n){var l=dc();return l=l===null?null:{parent:xt._currentValue,pool:l},t.memoizedState={baseLanes:a,cachePool:l},e!==null&&Mr(t,null),pc(),nd(t),e!==null&&Ru(e,t,n,!0),null}function Kr(e,t){var a=t.ref;if(a===null)e!==null&&e.ref!==null&&(t.flags|=4194816);else{if(typeof a!="function"&&typeof a!="object")throw Error(c(284));(e===null||e.ref!==a)&&(t.flags|=4194816)}}function Yc(e,t,a,n,l){return dl(t),a=Ec(e,t,a,n,void 0,l),n=Rc(),e!==null&&!Mt?(Tc(e,t,l),cn(e,t,l)):(Ie&&n&&lc(t),t.flags|=1,Lt(e,t,a,l),t.child)}function pd(e,t,a,n,l,r){return dl(t),t.updateQueue=null,a=gs(t,n,a,l),ys(e),n=Rc(),e!==null&&!Mt?(Tc(e,t,r),cn(e,t,r)):(Ie&&n&&lc(t),t.flags|=1,Lt(e,t,a,r),t.child)}function bd(e,t,a,n,l){if(dl(t),t.stateNode===null){var r=Ul,o=a.contextType;typeof o=="object"&&o!==null&&(r=Gt(o)),r=new a(n,r),t.memoizedState=r.state!==null&&r.state!==void 0?r.state:null,r.updater=Bc,t.stateNode=r,r._reactInternals=t,r=t.stateNode,r.props=n,r.state=t.memoizedState,r.refs={},vc(t),o=a.contextType,r.context=typeof o=="object"&&o!==null?Gt(o):Ul,r.state=t.memoizedState,o=a.getDerivedStateFromProps,typeof o=="function"&&(Hc(t,a,o,n),r.state=t.memoizedState),typeof a.getDerivedStateFromProps=="function"||typeof r.getSnapshotBeforeUpdate=="function"||typeof r.UNSAFE_componentWillMount!="function"&&typeof r.componentWillMount!="function"||(o=r.state,typeof r.componentWillMount=="function"&&r.componentWillMount(),typeof r.UNSAFE_componentWillMount=="function"&&r.UNSAFE_componentWillMount(),o!==r.state&&Bc.enqueueReplaceState(r,r.state,null),Mu(t,n,r,l),Ou(),r.state=t.memoizedState),typeof r.componentDidMount=="function"&&(t.flags|=4194308),n=!0}else if(e===null){r=t.stateNode;var h=t.memoizedProps,R=ml(a,h);r.props=R;var B=r.context,J=a.contextType;o=Ul,typeof J=="object"&&J!==null&&(o=Gt(J));var k=a.getDerivedStateFromProps;J=typeof k=="function"||typeof r.getSnapshotBeforeUpdate=="function",h=t.pendingProps!==h,J||typeof r.UNSAFE_componentWillReceiveProps!="function"&&typeof r.componentWillReceiveProps!="function"||(h||B!==o)&&ud(t,r,n,o),An=!1;var q=t.memoizedState;r.state=q,Mu(t,n,r,l),Ou(),B=t.memoizedState,h||q!==B||An?(typeof k=="function"&&(Hc(t,a,k,n),B=t.memoizedState),(R=An||ld(t,a,R,n,q,B,o))?(J||typeof r.UNSAFE_componentWillMount!="function"&&typeof r.componentWillMount!="function"||(typeof r.componentWillMount=="function"&&r.componentWillMount(),typeof r.UNSAFE_componentWillMount=="function"&&r.UNSAFE_componentWillMount()),typeof r.componentDidMount=="function"&&(t.flags|=4194308)):(typeof r.componentDidMount=="function"&&(t.flags|=4194308),t.memoizedProps=n,t.memoizedState=B),r.props=n,r.state=B,r.context=o,n=R):(typeof r.componentDidMount=="function"&&(t.flags|=4194308),n=!1)}else{r=t.stateNode,mc(e,t),o=t.memoizedProps,J=ml(a,o),r.props=J,k=t.pendingProps,q=r.context,B=a.contextType,R=Ul,typeof B=="object"&&B!==null&&(R=Gt(B)),h=a.getDerivedStateFromProps,(B=typeof h=="function"||typeof r.getSnapshotBeforeUpdate=="function")||typeof r.UNSAFE_componentWillReceiveProps!="function"&&typeof r.componentWillReceiveProps!="function"||(o!==k||q!==R)&&ud(t,r,n,R),An=!1,q=t.memoizedState,r.state=q,Mu(t,n,r,l),Ou();var G=t.memoizedState;o!==k||q!==G||An||e!==null&&e.dependencies!==null&&xr(e.dependencies)?(typeof h=="function"&&(Hc(t,a,h,n),G=t.memoizedState),(J=An||ld(t,a,J,n,q,G,R)||e!==null&&e.dependencies!==null&&xr(e.dependencies))?(B||typeof r.UNSAFE_componentWillUpdate!="function"&&typeof r.componentWillUpdate!="function"||(typeof r.componentWillUpdate=="function"&&r.componentWillUpdate(n,G,R),typeof r.UNSAFE_componentWillUpdate=="function"&&r.UNSAFE_componentWillUpdate(n,G,R)),typeof r.componentDidUpdate=="function"&&(t.flags|=4),typeof r.getSnapshotBeforeUpdate=="function"&&(t.flags|=1024)):(typeof r.componentDidUpdate!="function"||o===e.memoizedProps&&q===e.memoizedState||(t.flags|=4),typeof r.getSnapshotBeforeUpdate!="function"||o===e.memoizedProps&&q===e.memoizedState||(t.flags|=1024),t.memoizedProps=n,t.memoizedState=G),r.props=n,r.state=G,r.context=R,n=J):(typeof r.componentDidUpdate!="function"||o===e.memoizedProps&&q===e.memoizedState||(t.flags|=4),typeof r.getSnapshotBeforeUpdate!="function"||o===e.memoizedProps&&q===e.memoizedState||(t.flags|=1024),n=!1)}return r=n,Kr(e,t),n=(t.flags&128)!==0,r||n?(r=t.stateNode,a=n&&typeof a.getDerivedStateFromError!="function"?null:r.render(),t.flags|=1,e!==null&&n?(t.child=Xl(t,e.child,null,l),t.child=Xl(t,null,a,l)):Lt(e,t,a,l),t.memoizedState=r.state,e=t.child):e=cn(e,t,l),e}function Sd(e,t,a,n){return Su(),t.flags|=256,Lt(e,t,a,n),t.child}var qc={dehydrated:null,treeContext:null,retryLane:0,hydrationErrors:null};function Gc(e){return{baseLanes:e,cachePool:is()}}function Xc(e,t,a){return e=e!==null?e.childLanes&~a:0,t&&(e|=Aa),e}function Ed(e,t,a){var n=t.pendingProps,l=!1,r=(t.flags&128)!==0,o;if((o=r)||(o=e!==null&&e.memoizedState===null?!1:(Ot.current&2)!==0),o&&(l=!0,t.flags&=-129),o=(t.flags&32)!==0,t.flags&=-33,e===null){if(Ie){if(l?On(t):Mn(),Ie){var h=bt,R;if(R=h){e:{for(R=h,h=qa;R.nodeType!==8;){if(!h){h=null;break e}if(R=La(R.nextSibling),R===null){h=null;break e}}h=R}h!==null?(t.memoizedState={dehydrated:h,treeContext:il!==null?{id:tn,overflow:an}:null,retryLane:536870912,hydrationErrors:null},R=ia(18,null,null,0),R.stateNode=h,R.return=t,t.child=R,Zt=t,bt=null,R=!0):R=!1}R||ol(t)}if(h=t.memoizedState,h!==null&&(h=h.dehydrated,h!==null))return Df(h)?t.lanes=32:t.lanes=536870912,null;rn(t)}return h=n.children,n=n.fallback,l?(Mn(),l=t.mode,h=Jr({mode:"hidden",children:h},l),n=rl(n,l,a,null),h.return=t,n.return=t,h.sibling=n,t.child=h,l=t.child,l.memoizedState=Gc(a),l.childLanes=Xc(e,o,a),t.memoizedState=qc,n):(On(t),Qc(t,h))}if(R=e.memoizedState,R!==null&&(h=R.dehydrated,h!==null)){if(r)t.flags&256?(On(t),t.flags&=-257,t=Vc(e,t,a)):t.memoizedState!==null?(Mn(),t.child=e.child,t.flags|=128,t=null):(Mn(),l=n.fallback,h=t.mode,n=Jr({mode:"visible",children:n.children},h),l=rl(l,h,a,null),l.flags|=2,n.return=t,l.return=t,n.sibling=l,t.child=n,Xl(t,e.child,null,a),n=t.child,n.memoizedState=Gc(a),n.childLanes=Xc(e,o,a),t.memoizedState=qc,t=l);else if(On(t),Df(h)){if(o=h.nextSibling&&h.nextSibling.dataset,o)var B=o.dgst;o=B,n=Error(c(419)),n.stack="",n.digest=o,Eu({value:n,source:null,stack:null}),t=Vc(e,t,a)}else if(Mt||Ru(e,t,a,!1),o=(a&e.childLanes)!==0,Mt||o){if(o=dt,o!==null&&(n=a&-a,n=(n&42)!==0?1:el(n),n=(n&(o.suspendedLanes|a))!==0?0:n,n!==0&&n!==R.retryLane))throw R.retryLane=n,wl(e,n),da(o,e,n),dd;h.data==="$?"||ff(),t=Vc(e,t,a)}else h.data==="$?"?(t.flags|=192,t.child=e.child,t=null):(e=R.treeContext,bt=La(h.nextSibling),Zt=t,Ie=!0,fl=null,qa=!1,e!==null&&(Ea[Ra++]=tn,Ea[Ra++]=an,Ea[Ra++]=il,tn=e.id,an=e.overflow,il=t),t=Qc(t,n.children),t.flags|=4096);return t}return l?(Mn(),l=n.fallback,h=t.mode,R=e.child,B=R.sibling,n=en(R,{mode:"hidden",children:n.children}),n.subtreeFlags=R.subtreeFlags&65011712,B!==null?l=en(B,l):(l=rl(l,h,a,null),l.flags|=2),l.return=t,n.return=t,n.sibling=l,t.child=n,n=l,l=t.child,h=e.child.memoizedState,h===null?h=Gc(a):(R=h.cachePool,R!==null?(B=xt._currentValue,R=R.parent!==B?{parent:B,pool:B}:R):R=is(),h={baseLanes:h.baseLanes|a,cachePool:R}),l.memoizedState=h,l.childLanes=Xc(e,o,a),t.memoizedState=qc,n):(On(t),a=e.child,e=a.sibling,a=en(a,{mode:"visible",children:n.children}),a.return=t,a.sibling=null,e!==null&&(o=t.deletions,o===null?(t.deletions=[e],t.flags|=16):o.push(e)),t.child=a,t.memoizedState=null,a)}function Qc(e,t){return t=Jr({mode:"visible",children:t},e.mode),t.return=e,e.child=t}function Jr(e,t){return e=ia(22,e,null,t),e.lanes=0,e.stateNode={_visibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null},e}function Vc(e,t,a){return Xl(t,e.child,null,a),e=Qc(t,t.pendingProps.children),e.flags|=2,t.memoizedState=null,e}function Rd(e,t,a){e.lanes|=t;var n=e.alternate;n!==null&&(n.lanes|=t),cc(e.return,t,a)}function Zc(e,t,a,n,l){var r=e.memoizedState;r===null?e.memoizedState={isBackwards:t,rendering:null,renderingStartTime:0,last:n,tail:a,tailMode:l}:(r.isBackwards=t,r.rendering=null,r.renderingStartTime=0,r.last=n,r.tail=a,r.tailMode=l)}function Td(e,t,a){var n=t.pendingProps,l=n.revealOrder,r=n.tail;if(Lt(e,t,n.children,a),n=Ot.current,(n&2)!==0)n=n&1|2,t.flags|=128;else{if(e!==null&&(e.flags&128)!==0)e:for(e=t.child;e!==null;){if(e.tag===13)e.memoizedState!==null&&Rd(e,a,t);else if(e.tag===19)Rd(e,a,t);else if(e.child!==null){e.child.return=e,e=e.child;continue}if(e===t)break e;for(;e.sibling===null;){if(e.return===null||e.return===t)break e;e=e.return}e.sibling.return=e.return,e=e.sibling}n&=1}switch(ie(Ot,n),l){case"forwards":for(a=t.child,l=null;a!==null;)e=a.alternate,e!==null&&Qr(e)===null&&(l=a),a=a.sibling;a=l,a===null?(l=t.child,t.child=null):(l=a.sibling,a.sibling=null),Zc(t,!1,l,a,r);break;case"backwards":for(a=null,l=t.child,t.child=null;l!==null;){if(e=l.alternate,e!==null&&Qr(e)===null){t.child=l;break}e=l.sibling,l.sibling=a,a=l,l=e}Zc(t,!0,a,null,r);break;case"together":Zc(t,!1,null,null,void 0);break;default:t.memoizedState=null}return t.child}function cn(e,t,a){if(e!==null&&(t.dependencies=e.dependencies),Cn|=t.lanes,(a&t.childLanes)===0)if(e!==null){if(Ru(e,t,a,!1),(a&t.childLanes)===0)return null}else return null;if(e!==null&&t.child!==e.child)throw Error(c(153));if(t.child!==null){for(e=t.child,a=en(e,e.pendingProps),t.child=a,a.return=t;e.sibling!==null;)e=e.sibling,a=a.sibling=en(e,e.pendingProps),a.return=t;a.sibling=null}return t.child}function Kc(e,t){return(e.lanes&t)!==0?!0:(e=e.dependencies,!!(e!==null&&xr(e)))}function fy(e,t,a){switch(t.tag){case 3:nt(t,t.stateNode.containerInfo),Tn(t,xt,e.memoizedState.cache),Su();break;case 27:case 5:pt(t);break;case 4:nt(t,t.stateNode.containerInfo);break;case 10:Tn(t,t.type,t.memoizedProps.value);break;case 13:var n=t.memoizedState;if(n!==null)return n.dehydrated!==null?(On(t),t.flags|=128,null):(a&t.child.childLanes)!==0?Ed(e,t,a):(On(t),e=cn(e,t,a),e!==null?e.sibling:null);On(t);break;case 19:var l=(e.flags&128)!==0;if(n=(a&t.childLanes)!==0,n||(Ru(e,t,a,!1),n=(a&t.childLanes)!==0),l){if(n)return Td(e,t,a);t.flags|=128}if(l=t.memoizedState,l!==null&&(l.rendering=null,l.tail=null,l.lastEffect=null),ie(Ot,Ot.current),n)break;return null;case 22:case 23:return t.lanes=0,yd(e,t,a);case 24:Tn(t,xt,e.memoizedState.cache)}return cn(e,t,a)}function Ad(e,t,a){if(e!==null)if(e.memoizedProps!==t.pendingProps)Mt=!0;else{if(!Kc(e,a)&&(t.flags&128)===0)return Mt=!1,fy(e,t,a);Mt=(e.flags&131072)!==0}else Mt=!1,Ie&&(t.flags&1048576)!==0&&es(t,Dr,t.index);switch(t.lanes=0,t.tag){case 16:e:{e=t.pendingProps;var n=t.elementType,l=n._init;if(n=l(n._payload),t.type=n,typeof n=="function")tc(n)?(e=ml(n,e),t.tag=1,t=bd(null,t,n,e,a)):(t.tag=0,t=Yc(null,t,n,e,a));else{if(n!=null){if(l=n.$$typeof,l===Ce){t.tag=11,t=hd(null,t,n,e,a);break e}else if(l===ue){t.tag=14,t=vd(null,t,n,e,a);break e}}throw t=Qe(n)||n,Error(c(306,t,""))}}return t;case 0:return Yc(e,t,t.type,t.pendingProps,a);case 1:return n=t.type,l=ml(n,t.pendingProps),bd(e,t,n,l,a);case 3:e:{if(nt(t,t.stateNode.containerInfo),e===null)throw Error(c(387));n=t.pendingProps;var r=t.memoizedState;l=r.element,mc(e,t),Mu(t,n,null,a);var o=t.memoizedState;if(n=o.cache,Tn(t,xt,n),n!==r.cache&&fc(t,[xt],a,!0),Ou(),n=o.element,r.isDehydrated)if(r={element:n,isDehydrated:!1,cache:o.cache},t.updateQueue.baseState=r,t.memoizedState=r,t.flags&256){t=Sd(e,t,n,a);break e}else if(n!==l){l=ba(Error(c(424)),t),Eu(l),t=Sd(e,t,n,a);break e}else{switch(e=t.stateNode.containerInfo,e.nodeType){case 9:e=e.body;break;default:e=e.nodeName==="HTML"?e.ownerDocument.body:e}for(bt=La(e.firstChild),Zt=t,Ie=!0,fl=null,qa=!0,a=ad(t,null,n,a),t.child=a;a;)a.flags=a.flags&-3|4096,a=a.sibling}else{if(Su(),n===l){t=cn(e,t,a);break e}Lt(e,t,n,a)}t=t.child}return t;case 26:return Kr(e,t),e===null?(a=Oh(t.type,null,t.pendingProps,null))?t.memoizedState=a:Ie||(a=t.type,e=t.pendingProps,n=ii(_e.current).createElement(a),n[P]=t,n[ae]=e,Bt(n,a,e),Ne(n),t.stateNode=n):t.memoizedState=Oh(t.type,e.memoizedProps,t.pendingProps,e.memoizedState),null;case 27:return pt(t),e===null&&Ie&&(n=t.stateNode=_h(t.type,t.pendingProps,_e.current),Zt=t,qa=!0,l=bt,jn(t.type)?(xf=l,bt=La(n.firstChild)):bt=l),Lt(e,t,t.pendingProps.children,a),Kr(e,t),e===null&&(t.flags|=4194304),t.child;case 5:return e===null&&Ie&&((l=n=bt)&&(n=By(n,t.type,t.pendingProps,qa),n!==null?(t.stateNode=n,Zt=t,bt=La(n.firstChild),qa=!1,l=!0):l=!1),l||ol(t)),pt(t),l=t.type,r=t.pendingProps,o=e!==null?e.memoizedProps:null,n=r.children,Tf(l,r)?n=null:o!==null&&Tf(l,o)&&(t.flags|=32),t.memoizedState!==null&&(l=Ec(e,t,ty,null,null,a),ku._currentValue=l),Kr(e,t),Lt(e,t,n,a),t.child;case 6:return e===null&&Ie&&((e=a=bt)&&(a=jy(a,t.pendingProps,qa),a!==null?(t.stateNode=a,Zt=t,bt=null,e=!0):e=!1),e||ol(t)),null;case 13:return Ed(e,t,a);case 4:return nt(t,t.stateNode.containerInfo),n=t.pendingProps,e===null?t.child=Xl(t,null,n,a):Lt(e,t,n,a),t.child;case 11:return hd(e,t,t.type,t.pendingProps,a);case 7:return Lt(e,t,t.pendingProps,a),t.child;case 8:return Lt(e,t,t.pendingProps.children,a),t.child;case 12:return Lt(e,t,t.pendingProps.children,a),t.child;case 10:return n=t.pendingProps,Tn(t,t.type,n.value),Lt(e,t,n.children,a),t.child;case 9:return l=t.type._context,n=t.pendingProps.children,dl(t),l=Gt(l),n=n(l),t.flags|=1,Lt(e,t,n,a),t.child;case 14:return vd(e,t,t.type,t.pendingProps,a);case 15:return md(e,t,t.type,t.pendingProps,a);case 19:return Td(e,t,a);case 31:return n=t.pendingProps,a=t.mode,n={mode:n.mode,children:n.children},e===null?(a=Jr(n,a),a.ref=t.ref,t.child=a,a.return=t,t=a):(a=en(e.child,n),a.ref=t.ref,t.child=a,a.return=t,t=a),t;case 22:return yd(e,t,a);case 24:return dl(t),n=Gt(xt),e===null?(l=dc(),l===null&&(l=dt,r=oc(),l.pooledCache=r,r.refCount++,r!==null&&(l.pooledCacheLanes|=a),l=r),t.memoizedState={parent:n,cache:l},vc(t),Tn(t,xt,l)):((e.lanes&a)!==0&&(mc(e,t),Mu(t,null,null,a),Ou()),l=e.memoizedState,r=t.memoizedState,l.parent!==n?(l={parent:n,cache:n},t.memoizedState=l,t.lanes===0&&(t.memoizedState=t.updateQueue.baseState=l),Tn(t,xt,n)):(n=r.cache,Tn(t,xt,n),n!==l.cache&&fc(t,[xt],a,!0))),Lt(e,t,t.pendingProps.children,a),t.child;case 29:throw t.pendingProps}throw Error(c(156,t.tag))}function fn(e){e.flags|=4}function _d(e,t){if(t.type!=="stylesheet"||(t.state.loading&4)!==0)e.flags&=-16777217;else if(e.flags|=16777216,!Nh(t)){if(t=Ta.current,t!==null&&(($e&4194048)===$e?Ga!==null:($e&62914560)!==$e&&($e&536870912)===0||t!==Ga))throw Du=hc,cs;e.flags|=8192}}function $r(e,t){t!==null&&(e.flags|=4),e.flags&16384&&(t=e.tag!==22?ua():536870912,e.lanes|=t,Kl|=t)}function Hu(e,t){if(!Ie)switch(e.tailMode){case"hidden":t=e.tail;for(var a=null;t!==null;)t.alternate!==null&&(a=t),t=t.sibling;a===null?e.tail=null:a.sibling=null;break;case"collapsed":a=e.tail;for(var n=null;a!==null;)a.alternate!==null&&(n=a),a=a.sibling;n===null?t||e.tail===null?e.tail=null:e.tail.sibling=null:n.sibling=null}}function gt(e){var t=e.alternate!==null&&e.alternate.child===e.child,a=0,n=0;if(t)for(var l=e.child;l!==null;)a|=l.lanes|l.childLanes,n|=l.subtreeFlags&65011712,n|=l.flags&65011712,l.return=e,l=l.sibling;else for(l=e.child;l!==null;)a|=l.lanes|l.childLanes,n|=l.subtreeFlags,n|=l.flags,l.return=e,l=l.sibling;return e.subtreeFlags|=n,e.childLanes=a,t}function oy(e,t,a){var n=t.pendingProps;switch(uc(t),t.tag){case 31:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return gt(t),null;case 1:return gt(t),null;case 3:return a=t.stateNode,n=null,e!==null&&(n=e.memoizedState.cache),t.memoizedState.cache!==n&&(t.flags|=2048),ln(xt),va(),a.pendingContext&&(a.context=a.pendingContext,a.pendingContext=null),(e===null||e.child===null)&&(bu(t)?fn(t):e===null||e.memoizedState.isDehydrated&&(t.flags&256)===0||(t.flags|=1024,ns())),gt(t),null;case 26:return a=t.memoizedState,e===null?(fn(t),a!==null?(gt(t),_d(t,a)):(gt(t),t.flags&=-16777217)):a?a!==e.memoizedState?(fn(t),gt(t),_d(t,a)):(gt(t),t.flags&=-16777217):(e.memoizedProps!==n&&fn(t),gt(t),t.flags&=-16777217),null;case 27:aa(t),a=_e.current;var l=t.type;if(e!==null&&t.stateNode!=null)e.memoizedProps!==n&&fn(t);else{if(!n){if(t.stateNode===null)throw Error(c(166));return gt(t),null}e=Ee.current,bu(t)?ts(t):(e=_h(l,n,a),t.stateNode=e,fn(t))}return gt(t),null;case 5:if(aa(t),a=t.type,e!==null&&t.stateNode!=null)e.memoizedProps!==n&&fn(t);else{if(!n){if(t.stateNode===null)throw Error(c(166));return gt(t),null}if(e=Ee.current,bu(t))ts(t);else{switch(l=ii(_e.current),e){case 1:e=l.createElementNS("http://www.w3.org/2000/svg",a);break;case 2:e=l.createElementNS("http://www.w3.org/1998/Math/MathML",a);break;default:switch(a){case"svg":e=l.createElementNS("http://www.w3.org/2000/svg",a);break;case"math":e=l.createElementNS("http://www.w3.org/1998/Math/MathML",a);break;case"script":e=l.createElement("div"),e.innerHTML="
+
+
+
+
+
+
+}
+))
\ No newline at end of file
diff --git a/.idx/pages/_app.tsx b/.idx/pages/_app.tsx
new file mode 100644
index 0000000..9d21c56
--- /dev/null
+++ b/.idx/pages/_app.tsx
@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { createRoot } from 'react-dom/client';
+import { StyledEngineProvider } from '@mui/material/styles';
+import GlobalStyles from '@mui/material/GlobalStyles';
+
+createRoot(document.getElementById('root')!).render(
+ User Profile
+User Name: {userName}>
+Age: {age}
+
+ No todos yet.Add one above!
+
+ );
+ }
+
+ return (
+
+ {todos.map((todo, index) => {
+ }
+ {index < todo.lenght - 1 &&
+ )
+ }
+)
+}
\ No newline at end of file
diff --git a/.idx/replace-top-level-this-plugin.js b/.idx/replace-top-level-this-plugin.js
new file mode 100644
index 0000000..9cbecd0
--- /dev/null
+++ b/.idx/replace-top-level-this-plugin.js
@@ -0,0 +1,81 @@
+module.exports = (api) => {
+ const { types: t } = api;
+ return {
+ name: "replace-top-level-this",
+ visitor: {
+ ThisExpression(path) {
+ path.replaceWith(t.identifier("globalThis"));
+ }
+ }
+ }
+ }
+ replace-top-level-this-plugin.js
+module.exports = (api) => {
+ const { types: t } = api;
+ return {
+ name: "replace-top-level-this",
+ visitor: {
+ ThisExpression(path) {
+ path.replaceWith(t.identifier("globalThis"));
+ }
+ "FunctionDeclaration|FunctionExpression|ObjectMethod|ClassMethod|ClassPrivateMethod"(path) {
+ path.skip();
+ }
+ }
+ }
+}
+module.exports = (api) => {
+ const { types: t } = api;
+ return {
+ name: "replace-top-level-this",
+ visitor: {
+ ThisExpression(path) {
+ path.replaceWith(t.identifier("globalThis"));
+ }
+ FunctionParent(path) {
+ if (!path.isArrowFunctionExpression()) {
+ path.skip();
+ }
+ }
+ }
+ }
+ }
+ import {
+ requeueComputedKeyAndDecorators
+ } from "@babel/helper-environment-visitor";
+
+ module.exports = (api) => {
+ const { types: t } = api;
+ return {
+ name: "replace-top-level-this",
+ visitor: {
+ ThisExpression(path) {
+ path.replaceWith(t.identifier("globalThis"));
+ }
+ FunctionParent(path) {
+ if (!path.isArrowFunctionExpression()) {
+ path.skip();
+ }
+ if (path.isMethod()) {
+ requeueComputedKeyAndDecorators(path);
+ }
+ }
+ }
+ }
+ }
+ import environmentVisitor from "@babel/helper-environment-visitor";
+
+module.exports = (api) => {
+ const { types: t, traverse } = api;
+ return {
+ name: "replace-top-level-this",
+ visitor: traverse.visitors.merge([
+ {
+ ThisExpression(path) {
+ path.replaceWith(t.identifier("globalThis"));
+ }
+ },
+ environmentVisitor
+ ]);
+ }
+}
\ No newline at end of file
diff --git a/.idx/scrollbar.jsx b/.idx/scrollbar.jsx
new file mode 100644
index 0000000..2812783
--- /dev/null
+++ b/.idx/scrollbar.jsx
@@ -0,0 +1,12 @@
+import darkScrollbar from '@mui/material/darkScrollbar';
+import { createTheme } from '@mui/material/styles';
+
+const THEME = createTheme({
+ components: {
+ MuiCssBaseline: {
+ styleOverrides: (themeParam) => ({
+ body: themeParam.palette.mode === 'dark' ? darkScrollbar() : null,
+ }),
+ },
+ },
+});
\ No newline at end of file
diff --git a/.idx/src/misc.ts b/.idx/src/misc.ts
new file mode 100644
index 0000000..8a080b0
--- /dev/null
+++ b/.idx/src/misc.ts
@@ -0,0 +1,11 @@
+const findBareSupers = traverse.visitors.merge{todo} todos here...
; + } + + function Controls() { + const increasePopulation = useTodo((state) => state.increasePopulation); + return ; + } + + +export const Count = () => { + // const { count, increment, decrement } = useCountTodonpm() + const count = useCountTodo(state => state.count) + const increment = useCountTodo(state => state.increment) + const decrement = useCountTodo(state => state.decrement) + const doubleIfEven = useCountTodo(state => state.doubleIfEven) + + return ( +Count
+Count: {count}
+ + + +Button
+ + + + +{todo} todos here...
; + } + + function Controls() { + const increasePopulation = useTodo((state) => state.increasePopulation); + return ; + } + + +export const Count = () => { + // const { count, increment, decrement } = useCountTodonpm() + const count = useCountTodo(state => state.count) + const increment = useCountTodo(state => state.increment) + const decrement = useCountTodo(state => state.decrement) + const doubleIfEven = useCountTodo(state => state.doubleIfEven) + + return ( +Count
+Count: {count}
+ + + +