larry babby and threejs for glsl

webGl/my-threejs-test/node_modules/@parcel/events/lib/Disposable.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+var _errors = require("./errors");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * A general-purpose disposable class. It can normalize disposable-like values
+ * (such as single functions or IDisposables), as well as hold multiple
+ * disposable-like values to be disposed of at once.
+ */
+class Disposable {
+  disposed = false;
+  #disposables /*: ?Set<DisposableLike> */;
+
+  constructor(...disposables) {
+    this.#disposables = new Set(disposables);
+  }
+  add(...disposables) {
+    if (this.disposed) {
+      throw new _errors.AlreadyDisposedError('Cannot add new disposables after disposable has been disposed');
+    }
+    (0, _assert().default)(this.#disposables != null);
+    for (let disposable of disposables) {
+      this.#disposables.add(disposable);
+    }
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    (0, _assert().default)(this.#disposables != null);
+    await Promise.all([...this.#disposables].map(disposable => typeof disposable === 'function' ? disposable() : disposable.dispose()));
+    this.#disposables = null;
+  }
+}
+exports.default = Disposable;

webGl/my-threejs-test/node_modules/@parcel/events/lib/ValueEmitter.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _errors = require("./errors");
+// Like an EventEmitter, but for only a single "event". This provides type-safety
+// for the values emitted. Rather than passing predetermined strings (which can
+// be misspelled), create an instance of ValueEmitter for every logical "event"
+// to be dispatched, and type it according to the type of value emitted.
+class ValueEmitter {
+  // An array of listeners. One might think a Set would be better for O(1) removal,
+  // but splicing a JS array gets pretty close, and copying the array (as is done
+  // in emit) is far faster than a Set copy: https://github.com/atom/event-kit/pull/39
+  _listeners = [];
+  _disposed = false;
+  addListener(listener) {
+    if (this._disposed) {
+      throw new _errors.AlreadyDisposedError('Cannot add a listener since this ValueEmitter has been disposed');
+    }
+    this._listeners.push(listener);
+
+    // Close over a reference to this emitter in the disposable below, rather
+    // than referencing `this` directly. This allows us to set it to null after
+    // slicing out the listener.
+    // This prevents anyone holding onto the disposable after disposal from
+    // unintentionally retaining a reference to this emitter.
+    let emitter = this;
+    return {
+      dispose() {
+        if (emitter == null) {
+          return;
+        }
+        if (emitter._disposed) {
+          emitter = null;
+          return;
+        }
+        let listeners = emitter._listeners;
+        let listenerIndex = listeners.indexOf(listener);
+        if (listenerIndex > -1) {
+          listeners.splice(listenerIndex, 1);
+        }
+        emitter = null;
+      }
+    };
+  }
+  emit(value) {
+    if (this._disposed) {
+      throw new _errors.AlreadyDisposedError('Cannot emit since this ValueEmitter has been disposed');
+    }
+
+    // Iterate over a copy of listeners. This prevents the following cases:
+    // * When a listener callback can itself register a new listener and be
+    //   emitted as part of this iteration.
+    // * When a listener callback disposes of this emitter mid-emit, preventing
+    //   other listeners from receiving the event.
+    let listeners = this._listeners.slice();
+    for (let i = 0; i < listeners.length; i++) {
+      listeners[i](value);
+    }
+  }
+  dispose() {
+    if (this._disposed) {
+      return;
+    }
+    this._listeners = [];
+    this._disposed = true;
+  }
+}
+exports.default = ValueEmitter;

webGl/my-threejs-test/node_modules/@parcel/events/lib/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AlreadyDisposedError = void 0;
+class AlreadyDisposedError extends Error {}
+exports.AlreadyDisposedError = AlreadyDisposedError;
+Object.defineProperty(AlreadyDisposedError.prototype, 'name', {
+  value: 'AlreadyDisposedError'
+});

webGl/my-threejs-test/node_modules/@parcel/events/lib/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AlreadyDisposedError", {
+  enumerable: true,
+  get: function () {
+    return _errors.AlreadyDisposedError;
+  }
+});
+Object.defineProperty(exports, "Disposable", {
+  enumerable: true,
+  get: function () {
+    return _Disposable.default;
+  }
+});
+Object.defineProperty(exports, "ValueEmitter", {
+  enumerable: true,
+  get: function () {
+    return _ValueEmitter.default;
+  }
+});
+var _Disposable = _interopRequireDefault(require("./Disposable"));
+var _ValueEmitter = _interopRequireDefault(require("./ValueEmitter"));
+var _errors = require("./errors");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

webGl/my-threejs-test/node_modules/@parcel/events/lib/types.js

@@ -0,0 +1 @@
+"use strict";