@volter/tabnode 0.2.14-volter.88

package/src/node-lib/constants.js

@@ -0,0 +1,41 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+
+const {
+  ObjectAssign,
+  ObjectFreeze,
+} = primordials;
+
+// This module is deprecated in documentation only. Users should be directed
+// towards using the specific constants exposed by the individual modules on
+// which they are most relevant.
+// Deprecation Code: DEP0008
+const constants = internalBinding('constants');
+ObjectAssign(exports,
+             constants.os.dlopen,
+             constants.os.errno,
+             constants.os.priority,
+             constants.os.signals,
+             constants.fs,
+             constants.crypto);
+ObjectFreeze(exports);

package/src/node-lib/diagnostics_channel.js

@@ -0,0 +1,438 @@
+'use strict';
+
+const {
+  ArrayPrototypeAt,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypePush,
+  ArrayPrototypePushApply,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSplice,
+  ObjectDefineProperty,
+  ObjectGetPrototypeOf,
+  ObjectSetPrototypeOf,
+  Promise,
+  PromisePrototypeThen,
+  PromiseReject,
+  PromiseResolve,
+  ReflectApply,
+  SafeFinalizationRegistry,
+  SafeMap,
+  SymbolHasInstance,
+} = primordials;
+
+const {
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+  },
+} = require('internal/errors');
+const {
+  validateFunction,
+} = require('internal/validators');
+
+const { triggerUncaughtException } = internalBinding('errors');
+
+const { WeakReference } = require('internal/util');
+
+// Can't delete when weakref count reaches 0 as it could increment again.
+// Only GC can be used as a valid time to clean up the channels map.
+class WeakRefMap extends SafeMap {
+  #finalizers = new SafeFinalizationRegistry((key) => {
+    this.delete(key);
+  });
+
+  set(key, value) {
+    this.#finalizers.register(value, key);
+    return super.set(key, new WeakReference(value));
+  }
+
+  get(key) {
+    return super.get(key)?.get();
+  }
+
+  incRef(key) {
+    return super.get(key)?.incRef();
+  }
+
+  decRef(key) {
+    return super.get(key)?.decRef();
+  }
+}
+
+function markActive(channel) {
+  // eslint-disable-next-line no-use-before-define
+  ObjectSetPrototypeOf(channel, ActiveChannel.prototype);
+  channel._subscribers = [];
+  channel._stores = new SafeMap();
+}
+
+function maybeMarkInactive(channel) {
+  // When there are no more active subscribers or bound, restore to fast prototype.
+  if (!channel._subscribers.length && !channel._stores.size) {
+    // eslint-disable-next-line no-use-before-define
+    ObjectSetPrototypeOf(channel, Channel.prototype);
+    channel._subscribers = undefined;
+    channel._stores = undefined;
+  }
+}
+
+function defaultTransform(data) {
+  return data;
+}
+
+function wrapStoreRun(store, data, next, transform = defaultTransform) {
+  return () => {
+    let context;
+    try {
+      context = transform(data);
+    } catch (err) {
+      process.nextTick(() => {
+        triggerUncaughtException(err, false);
+      });
+      return next();
+    }
+
+    return store.run(context, next);
+  };
+}
+
+// TODO(qard): should there be a C++ channel interface?
+class ActiveChannel {
+  subscribe(subscription) {
+    validateFunction(subscription, 'subscription');
+    this._subscribers = ArrayPrototypeSlice(this._subscribers);
+    ArrayPrototypePush(this._subscribers, subscription);
+    channels.incRef(this.name);
+  }
+
+  unsubscribe(subscription) {
+    const index = ArrayPrototypeIndexOf(this._subscribers, subscription);
+    if (index === -1) return false;
+
+    const before = ArrayPrototypeSlice(this._subscribers, 0, index);
+    const after = ArrayPrototypeSlice(this._subscribers, index + 1);
+    this._subscribers = before;
+    ArrayPrototypePushApply(this._subscribers, after);
+
+    channels.decRef(this.name);
+    maybeMarkInactive(this);
+
+    return true;
+  }
+
+  bindStore(store, transform) {
+    const replacing = this._stores.has(store);
+    if (!replacing) channels.incRef(this.name);
+    this._stores.set(store, transform);
+  }
+
+  unbindStore(store) {
+    if (!this._stores.has(store)) {
+      return false;
+    }
+
+    this._stores.delete(store);
+
+    channels.decRef(this.name);
+    maybeMarkInactive(this);
+
+    return true;
+  }
+
+  get hasSubscribers() {
+    return true;
+  }
+
+  publish(data) {
+    const subscribers = this._subscribers;
+    for (let i = 0; i < (subscribers?.length || 0); i++) {
+      try {
+        const onMessage = subscribers[i];
+        onMessage(data, this.name);
+      } catch (err) {
+        process.nextTick(() => {
+          triggerUncaughtException(err, false);
+        });
+      }
+    }
+  }
+
+  runStores(data, fn, thisArg, ...args) {
+    let run = () => {
+      this.publish(data);
+      return ReflectApply(fn, thisArg, args);
+    };
+
+    for (const entry of this._stores.entries()) {
+      const store = entry[0];
+      const transform = entry[1];
+      run = wrapStoreRun(store, data, run, transform);
+    }
+
+    return run();
+  }
+}
+
+class Channel {
+  constructor(name) {
+    this._subscribers = undefined;
+    this._stores = undefined;
+    this.name = name;
+
+    channels.set(name, this);
+  }
+
+  static [SymbolHasInstance](instance) {
+    const prototype = ObjectGetPrototypeOf(instance);
+    return prototype === Channel.prototype ||
+           prototype === ActiveChannel.prototype;
+  }
+
+  subscribe(subscription) {
+    markActive(this);
+    this.subscribe(subscription);
+  }
+
+  unsubscribe() {
+    return false;
+  }
+
+  bindStore(store, transform) {
+    markActive(this);
+    this.bindStore(store, transform);
+  }
+
+  unbindStore() {
+    return false;
+  }
+
+  get hasSubscribers() {
+    return false;
+  }
+
+  publish() {}
+
+  runStores(data, fn, thisArg, ...args) {
+    return ReflectApply(fn, thisArg, args);
+  }
+}
+
+const channels = new WeakRefMap();
+
+function channel(name) {
+  const channel = channels.get(name);
+  if (channel) return channel;
+
+  if (typeof name !== 'string' && typeof name !== 'symbol') {
+    throw new ERR_INVALID_ARG_TYPE('channel', ['string', 'symbol'], name);
+  }
+
+  return new Channel(name);
+}
+
+function subscribe(name, subscription) {
+  return channel(name).subscribe(subscription);
+}
+
+function unsubscribe(name, subscription) {
+  return channel(name).unsubscribe(subscription);
+}
+
+function hasSubscribers(name) {
+  const channel = channels.get(name);
+  if (!channel) return false;
+
+  return channel.hasSubscribers;
+}
+
+const traceEvents = [
+  'start',
+  'end',
+  'asyncStart',
+  'asyncEnd',
+  'error',
+];
+
+function assertChannel(value, name) {
+  if (!(value instanceof Channel)) {
+    throw new ERR_INVALID_ARG_TYPE(name, ['Channel'], value);
+  }
+}
+
+function tracingChannelFrom(nameOrChannels, name) {
+  if (typeof nameOrChannels === 'string') {
+    return channel(`tracing:${nameOrChannels}:${name}`);
+  }
+
+  if (typeof nameOrChannels === 'object' && nameOrChannels !== null) {
+    const channel = nameOrChannels[name];
+    assertChannel(channel, `nameOrChannels.${name}`);
+    return channel;
+  }
+
+  throw new ERR_INVALID_ARG_TYPE('nameOrChannels',
+                                 ['string', 'object', 'TracingChannel'],
+                                 nameOrChannels);
+}
+
+class TracingChannel {
+  constructor(nameOrChannels) {
+    for (let i = 0; i < traceEvents.length; ++i) {
+      const eventName = traceEvents[i];
+      ObjectDefineProperty(this, eventName, {
+        __proto__: null,
+        value: tracingChannelFrom(nameOrChannels, eventName),
+      });
+    }
+  }
+
+  get hasSubscribers() {
+    return this.start?.hasSubscribers ||
+      this.end?.hasSubscribers ||
+      this.asyncStart?.hasSubscribers ||
+      this.asyncEnd?.hasSubscribers ||
+      this.error?.hasSubscribers;
+  }
+
+  subscribe(handlers) {
+    for (let i = 0; i < traceEvents.length; ++i) {
+      const name = traceEvents[i];
+      if (!handlers[name]) continue;
+
+      this[name]?.subscribe(handlers[name]);
+    }
+  }
+
+  unsubscribe(handlers) {
+    let done = true;
+
+    for (let i = 0; i < traceEvents.length; ++i) {
+      const name = traceEvents[i];
+      if (!handlers[name]) continue;
+
+      if (!this[name]?.unsubscribe(handlers[name])) {
+        done = false;
+      }
+    }
+
+    return done;
+  }
+
+  traceSync(fn, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return ReflectApply(fn, thisArg, args);
+    }
+
+    const { start, end, error } = this;
+
+    return start.runStores(context, () => {
+      try {
+        const result = ReflectApply(fn, thisArg, args);
+        context.result = result;
+        return result;
+      } catch (err) {
+        context.error = err;
+        error.publish(context);
+        throw err;
+      } finally {
+        end.publish(context);
+      }
+    });
+  }
+
+  tracePromise(fn, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return ReflectApply(fn, thisArg, args);
+    }
+
+    const { start, end, asyncStart, asyncEnd, error } = this;
+
+    function reject(err) {
+      context.error = err;
+      error.publish(context);
+      asyncStart.publish(context);
+      // TODO: Is there a way to have asyncEnd _after_ the continuation?
+      asyncEnd.publish(context);
+      return PromiseReject(err);
+    }
+
+    function resolve(result) {
+      context.result = result;
+      asyncStart.publish(context);
+      // TODO: Is there a way to have asyncEnd _after_ the continuation?
+      asyncEnd.publish(context);
+      return result;
+    }
+
+    return start.runStores(context, () => {
+      try {
+        let promise = ReflectApply(fn, thisArg, args);
+        // Convert thenables to native promises
+        if (!(promise instanceof Promise)) {
+          promise = PromiseResolve(promise);
+        }
+        return PromisePrototypeThen(promise, resolve, reject);
+      } catch (err) {
+        context.error = err;
+        error.publish(context);
+        throw err;
+      } finally {
+        end.publish(context);
+      }
+    });
+  }
+
+  traceCallback(fn, position = -1, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return ReflectApply(fn, thisArg, args);
+    }
+
+    const { start, end, asyncStart, asyncEnd, error } = this;
+
+    function wrappedCallback(err, res) {
+      if (err) {
+        context.error = err;
+        error.publish(context);
+      } else {
+        context.result = res;
+      }
+
+      // Using runStores here enables manual context failure recovery
+      asyncStart.runStores(context, () => {
+        try {
+          return ReflectApply(callback, this, arguments);
+        } finally {
+          asyncEnd.publish(context);
+        }
+      });
+    }
+
+    const callback = ArrayPrototypeAt(args, position);
+    validateFunction(callback, 'callback');
+    ArrayPrototypeSplice(args, position, 1, wrappedCallback);
+
+    return start.runStores(context, () => {
+      try {
+        return ReflectApply(fn, thisArg, args);
+      } catch (err) {
+        context.error = err;
+        error.publish(context);
+        throw err;
+      } finally {
+        end.publish(context);
+      }
+    });
+  }
+}
+
+function tracingChannel(nameOrChannels) {
+  return new TracingChannel(nameOrChannels);
+}
+
+module.exports = {
+  channel,
+  hasSubscribers,
+  subscribe,
+  tracingChannel,
+  unsubscribe,
+  Channel,
+};

package/src/node-lib/events-module.ts

@@ -0,0 +1,80 @@
+/**
+ * `events`, as Node's own `lib/events.js`.
+ *
+ * What died: the engine's `EventEmitter` was hand-written, 254 lines over a
+ * `Map` of arrays. Node's own `test-events-*`: 0 of 9 passed. The gaps were
+ * not exotic -- `events.once`, `events.on`, `captureRejections`, the
+ * `MaxListenersExceededWarning`, `getEventListeners`, an emitter's
+ * `[kCapture]`, the `error` event's special handling -- and each one was a
+ * program in the tab finding it. `stream` found one from the inside: Node's
+ * `readable.js` assigns `addListener = on`, so an `on` that delegated to
+ * `addListener` was an infinite recursion.
+ *
+ * What this is: Node's `lib/events.js` v22.18.0, vendored unmodified, over
+ * `internal/fixed_queue`, `internal/events/symbols` and the engine's own
+ * `internal/event_target` binding. `EventEmitter`, `once`, `on`,
+ * `setMaxListeners`, `addAbortListener` and the rest are Node's own code.
+ *
+ * The rule for this file: it binds, it does not implement.
+ */
+import { lazyExport } from './lazy';
+
+/** A listener, as the engine's own shims type one. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type EventListener = (...args: any[]) => void;
+
+/** Node's `EventEmitter`, as every part of the engine reads one. */
+export interface EventEmitter {
+  addListener(event: string | symbol, listener: EventListener): this;
+  on(event: string | symbol, listener: EventListener): this;
+  once(event: string | symbol, listener: EventListener): this;
+  removeListener(event: string | symbol, listener: EventListener): this;
+  off(event: string | symbol, listener: EventListener): this;
+  removeAllListeners(event?: string | symbol): this;
+  setMaxListeners(n: number): this;
+  getMaxListeners(): number;
+  listeners(event: string | symbol): Array<EventListener>;
+  rawListeners(event: string | symbol): Array<EventListener>;
+  emit(event: string | symbol, ...args: unknown[]): boolean;
+  listenerCount(event: string | symbol, listener?: EventListener): number;
+  prependListener(event: string | symbol, listener: EventListener): this;
+  prependOnceListener(event: string | symbol, listener: EventListener): this;
+  eventNames(): Array<string | symbol>;
+}
+
+/** The whole of Node's `events` module object. */
+export interface EventsModule {
+  EventEmitter: new (options?: { captureRejections?: boolean }) => EventEmitter;
+  EventEmitterAsyncResource: unknown;
+  once(emitter: unknown, name: string | symbol, options?: unknown): Promise<unknown[]>;
+  on(emitter: unknown, name: string | symbol, options?: unknown): AsyncIterableIterator<unknown[]>;
+  getEventListeners(emitter: unknown, name: string | symbol): Array<EventListener>;
+  getMaxListeners(emitter: unknown): number;
+  setMaxListeners(n?: number, ...emitters: unknown[]): void;
+  addAbortListener(signal: AbortSignal, listener: EventListener): Disposable;
+  listenerCount(emitter: unknown, type: string | symbol): number;
+  init: unknown;
+  captureRejectionSymbol: symbol;
+  errorMonitor: symbol;
+  usingDomains: boolean;
+  defaultMaxListeners: number;
+}
+
+/**
+ * The class itself, named before the loader can build it: the engine's own
+ * files construct and subclass it, and `./lazy.ts` says why a name here
+ * stands for the thing rather than being it.
+ */
+export const EventEmitter = lazyExport<EventsModule['EventEmitter']>('events', 'EventEmitter');
+
+/**
+ * The module, which in Node IS the class: `events.js` ends with
+ * `module.exports = EventEmitter` and hangs `once`, `on`, `getEventListeners`
+ * and the rest off it, so `require("events") === require("events")
+ * .EventEmitter` and `new (require("events"))()` is an emitter. One object
+ * here too, for the same reason -- a guest that constructs the module got
+ * "not a constructor" when this was a separate object standing beside it.
+ */
+export const eventsModule = EventEmitter as unknown as EventsModule;
+
+export default eventsModule;