Initial Sample.

graphql-subscription/node_modules/zen-observable-ts/.github/dependabot.yml

@@ -0,0 +1,9 @@
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "daily"

graphql-subscription/node_modules/zen-observable-ts/.github/workflows/node.js.yml

@@ -0,0 +1,30 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: ['10', '12', '14', '15', '16']
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm ci
+    - run: npm run build --if-present
+    - run: npm test

graphql-subscription/node_modules/zen-observable-ts/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Apollo Graph, Inc. (Formerly Meteor Development Group, Inc.)
+
+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.

graphql-subscription/node_modules/zen-observable-ts/README.md

@@ -0,0 +1,19 @@
+# zen-observable-ts
+
+Thin wrapper around [`zen-observable`](https://www.npmjs.com/package/zen-observable) and [`@types/zen-observable`](https://www.npmjs.com/package/@types/zen-observable), to support ESM exports as well as CommonJS exports, with TypeScript types provided by `@types/zen-observable`.
+
+## Usage
+
+After installing `zen-observable-ts` using a tool like [npm](https://www.npmjs.com/package/npm) or [yarn](https://yarnpkg.com/), you can import the `Observable` class by name:
+```js
+import { Observable } from "zen-observable-ts";
+```
+Note that this package does not currently have a default export, so the `{}` braces are mandatory.
+
+## Previous versions
+
+This tiny wrapper package replaces [an older version of `zen-observable-ts`](https://github.com/apollographql/apollo-link/tree/master/packages/zen-observable-ts) that used to provide TypeScript types for `zen-observable`, before `@types/zen-observable` was introduced. This version of the package is not intended to be perfectly compatible with the older version, so we have bumped the major version of the package to reflect the difference.
+
+## Future plans
+
+As explained in https://github.com/apollographql/apollo-client/pull/7615, the `zen-observable-ts` package exists to fill a gap in the functionality of the `zen-observable` package, so we will retire this package in favor of using `zen-observable` directly, when/if [this PR](https://github.com/zenparsing/zen-observable/pull/74) is ever merged.

graphql-subscription/node_modules/zen-observable-ts/index.cjs

@@ -0,0 +1 @@
+exports.Observable = require("zen-observable/index.js");

graphql-subscription/node_modules/zen-observable-ts/index.cjs.native.js

@@ -0,0 +1 @@
+exports.Observable = require("zen-observable/index.js");

graphql-subscription/node_modules/zen-observable-ts/module.d.ts

@@ -0,0 +1,58 @@
+export interface Subscription {
+  closed: boolean;
+  unsubscribe(): void;
+}
+
+interface SubscriptionObserver<T> {
+  closed: boolean;
+  next(value: T): void;
+  error(errorValue: any): void;
+  complete(): void;
+}
+
+export interface Observer<T> {
+  start?(subscription: Subscription): any;
+  next?(value: T): void;
+  error?(errorValue: any): void;
+  complete?(): void;
+}
+
+export type Subscriber<T> = (
+  observer: SubscriptionObserver<T>,
+) => void | (() => void) | Subscription;
+
+interface ObservableLike<T> {
+  subscribe?: Subscriber<T> | undefined;
+  [Symbol.observable](): Observable<T> | ObservableLike<T>;
+}
+
+export declare class Observable<T> {
+  constructor(subscriber: Subscriber<T>);
+
+  // For backwards compatibility when super(subscriber) is transpiled to
+  // Observable.call(this, subscriber), which typically happens when the
+  // Observable class is compiled to ES5 function contructor syntax.
+  static call<R>(instance: Observable<R>, subscriber: Subscriber<R>): undefined;
+  static apply<R>(instance: Observable<R>, args: IArguments | [Subscriber<R>]): undefined;
+
+  subscribe(observer: Observer<T>): Subscription;
+  subscribe(
+    onNext: (value: T) => void,
+    onError?: (error: any) => void,
+    onComplete?: () => void,
+  ): Subscription;
+
+  [Symbol.observable](): Observable<T>;
+
+  forEach(callback: (value: T) => void): Promise<void>;
+  map<R>(callback: (value: T) => R): Observable<R>;
+  filter<S extends T>(callback: (value: T) => value is S): Observable<S>;
+  filter(callback: (value: T) => boolean): Observable<T>;
+  reduce(callback: (previousValue: T, currentValue: T) => T, initialValue?: T): Observable<T>;
+  reduce<R>(callback: (previousValue: R, currentValue: T) => R, initialValue?: R): Observable<R>;
+  flatMap<R>(callback: (value: T) => ObservableLike<R>): Observable<R>;
+  concat<R>(...observable: Array<Observable<R>>): Observable<R>;
+
+  static from<R>(observable: Observable<R> | ObservableLike<R> | ArrayLike<R>): Observable<R>;
+  static of<R>(...items: R[]): Observable<R>;
+}

graphql-subscription/node_modules/zen-observable-ts/module.js

@@ -0,0 +1,576 @@
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+// === Symbol Support ===
+var hasSymbols = function () {
+  return typeof Symbol === 'function';
+};
+
+var hasSymbol = function (name) {
+  return hasSymbols() && Boolean(Symbol[name]);
+};
+
+var getSymbol = function (name) {
+  return hasSymbol(name) ? Symbol[name] : '@@' + name;
+};
+
+if (hasSymbols() && !hasSymbol('observable')) {
+  Symbol.observable = Symbol('observable');
+}
+
+var SymbolIterator = getSymbol('iterator');
+var SymbolObservable = getSymbol('observable');
+var SymbolSpecies = getSymbol('species'); // === Abstract Operations ===
+
+function getMethod(obj, key) {
+  var value = obj[key];
+  if (value == null) return undefined;
+  if (typeof value !== 'function') throw new TypeError(value + ' is not a function');
+  return value;
+}
+
+function getSpecies(obj) {
+  var ctor = obj.constructor;
+
+  if (ctor !== undefined) {
+    ctor = ctor[SymbolSpecies];
+
+    if (ctor === null) {
+      ctor = undefined;
+    }
+  }
+
+  return ctor !== undefined ? ctor : Observable;
+}
+
+function isObservable(x) {
+  return x instanceof Observable; // SPEC: Brand check
+}
+
+function hostReportError(e) {
+  if (hostReportError.log) {
+    hostReportError.log(e);
+  } else {
+    setTimeout(function () {
+      throw e;
+    });
+  }
+}
+
+function enqueue(fn) {
+  Promise.resolve().then(function () {
+    try {
+      fn();
+    } catch (e) {
+      hostReportError(e);
+    }
+  });
+}
+
+function cleanupSubscription(subscription) {
+  var cleanup = subscription._cleanup;
+  if (cleanup === undefined) return;
+  subscription._cleanup = undefined;
+
+  if (!cleanup) {
+    return;
+  }
+
+  try {
+    if (typeof cleanup === 'function') {
+      cleanup();
+    } else {
+      var unsubscribe = getMethod(cleanup, 'unsubscribe');
+
+      if (unsubscribe) {
+        unsubscribe.call(cleanup);
+      }
+    }
+  } catch (e) {
+    hostReportError(e);
+  }
+}
+
+function closeSubscription(subscription) {
+  subscription._observer = undefined;
+  subscription._queue = undefined;
+  subscription._state = 'closed';
+}
+
+function flushSubscription(subscription) {
+  var queue = subscription._queue;
+
+  if (!queue) {
+    return;
+  }
+
+  subscription._queue = undefined;
+  subscription._state = 'ready';
+
+  for (var i = 0; i < queue.length; ++i) {
+    notifySubscription(subscription, queue[i].type, queue[i].value);
+    if (subscription._state === 'closed') break;
+  }
+}
+
+function notifySubscription(subscription, type, value) {
+  subscription._state = 'running';
+  var observer = subscription._observer;
+
+  try {
+    var m = getMethod(observer, type);
+
+    switch (type) {
+      case 'next':
+        if (m) m.call(observer, value);
+        break;
+
+      case 'error':
+        closeSubscription(subscription);
+        if (m) m.call(observer, value);else throw value;
+        break;
+
+      case 'complete':
+        closeSubscription(subscription);
+        if (m) m.call(observer);
+        break;
+    }
+  } catch (e) {
+    hostReportError(e);
+  }
+
+  if (subscription._state === 'closed') cleanupSubscription(subscription);else if (subscription._state === 'running') subscription._state = 'ready';
+}
+
+function onNotify(subscription, type, value) {
+  if (subscription._state === 'closed') return;
+
+  if (subscription._state === 'buffering') {
+    subscription._queue.push({
+      type: type,
+      value: value
+    });
+
+    return;
+  }
+
+  if (subscription._state !== 'ready') {
+    subscription._state = 'buffering';
+    subscription._queue = [{
+      type: type,
+      value: value
+    }];
+    enqueue(function () {
+      return flushSubscription(subscription);
+    });
+    return;
+  }
+
+  notifySubscription(subscription, type, value);
+}
+
+var Subscription = /*#__PURE__*/function () {
+  function Subscription(observer, subscriber) {
+    // ASSERT: observer is an object
+    // ASSERT: subscriber is callable
+    this._cleanup = undefined;
+    this._observer = observer;
+    this._queue = undefined;
+    this._state = 'initializing';
+    var subscriptionObserver = new SubscriptionObserver(this);
+
+    try {
+      this._cleanup = subscriber.call(undefined, subscriptionObserver);
+    } catch (e) {
+      subscriptionObserver.error(e);
+    }
+
+    if (this._state === 'initializing') this._state = 'ready';
+  }
+
+  var _proto = Subscription.prototype;
+
+  _proto.unsubscribe = function unsubscribe() {
+    if (this._state !== 'closed') {
+      closeSubscription(this);
+      cleanupSubscription(this);
+    }
+  };
+
+  _createClass(Subscription, [{
+    key: "closed",
+    get: function () {
+      return this._state === 'closed';
+    }
+  }]);
+
+  return Subscription;
+}();
+
+var SubscriptionObserver = /*#__PURE__*/function () {
+  function SubscriptionObserver(subscription) {
+    this._subscription = subscription;
+  }
+
+  var _proto2 = SubscriptionObserver.prototype;
+
+  _proto2.next = function next(value) {
+    onNotify(this._subscription, 'next', value);
+  };
+
+  _proto2.error = function error(value) {
+    onNotify(this._subscription, 'error', value);
+  };
+
+  _proto2.complete = function complete() {
+    onNotify(this._subscription, 'complete');
+  };
+
+  _createClass(SubscriptionObserver, [{
+    key: "closed",
+    get: function () {
+      return this._subscription._state === 'closed';
+    }
+  }]);
+
+  return SubscriptionObserver;
+}();
+
+var Observable = /*#__PURE__*/function () {
+  function Observable(subscriber) {
+    if (!(this instanceof Observable)) throw new TypeError('Observable cannot be called as a function');
+    if (typeof subscriber !== 'function') throw new TypeError('Observable initializer must be a function');
+    this._subscriber = subscriber;
+  }
+
+  var _proto3 = Observable.prototype;
+
+  _proto3.subscribe = function subscribe(observer) {
+    if (typeof observer !== 'object' || observer === null) {
+      observer = {
+        next: observer,
+        error: arguments[1],
+        complete: arguments[2]
+      };
+    }
+
+    return new Subscription(observer, this._subscriber);
+  };
+
+  _proto3.forEach = function forEach(fn) {
+    var _this = this;
+
+    return new Promise(function (resolve, reject) {
+      if (typeof fn !== 'function') {
+        reject(new TypeError(fn + ' is not a function'));
+        return;
+      }
+
+      function done() {
+        subscription.unsubscribe();
+        resolve();
+      }
+
+      var subscription = _this.subscribe({
+        next: function (value) {
+          try {
+            fn(value, done);
+          } catch (e) {
+            reject(e);
+            subscription.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+    });
+  };
+
+  _proto3.map = function map(fn) {
+    var _this2 = this;
+
+    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
+    var C = getSpecies(this);
+    return new C(function (observer) {
+      return _this2.subscribe({
+        next: function (value) {
+          try {
+            value = fn(value);
+          } catch (e) {
+            return observer.error(e);
+          }
+
+          observer.next(value);
+        },
+        error: function (e) {
+          observer.error(e);
+        },
+        complete: function () {
+          observer.complete();
+        }
+      });
+    });
+  };
+
+  _proto3.filter = function filter(fn) {
+    var _this3 = this;
+
+    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
+    var C = getSpecies(this);
+    return new C(function (observer) {
+      return _this3.subscribe({
+        next: function (value) {
+          try {
+            if (!fn(value)) return;
+          } catch (e) {
+            return observer.error(e);
+          }
+
+          observer.next(value);
+        },
+        error: function (e) {
+          observer.error(e);
+        },
+        complete: function () {
+          observer.complete();
+        }
+      });
+    });
+  };
+
+  _proto3.reduce = function reduce(fn) {
+    var _this4 = this;
+
+    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
+    var C = getSpecies(this);
+    var hasSeed = arguments.length > 1;
+    var hasValue = false;
+    var seed = arguments[1];
+    var acc = seed;
+    return new C(function (observer) {
+      return _this4.subscribe({
+        next: function (value) {
+          var first = !hasValue;
+          hasValue = true;
+
+          if (!first || hasSeed) {
+            try {
+              acc = fn(acc, value);
+            } catch (e) {
+              return observer.error(e);
+            }
+          } else {
+            acc = value;
+          }
+        },
+        error: function (e) {
+          observer.error(e);
+        },
+        complete: function () {
+          if (!hasValue && !hasSeed) return observer.error(new TypeError('Cannot reduce an empty sequence'));
+          observer.next(acc);
+          observer.complete();
+        }
+      });
+    });
+  };
+
+  _proto3.concat = function concat() {
+    var _this5 = this;
+
+    for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
+      sources[_key] = arguments[_key];
+    }
+
+    var C = getSpecies(this);
+    return new C(function (observer) {
+      var subscription;
+      var index = 0;
+
+      function startNext(next) {
+        subscription = next.subscribe({
+          next: function (v) {
+            observer.next(v);
+          },
+          error: function (e) {
+            observer.error(e);
+          },
+          complete: function () {
+            if (index === sources.length) {
+              subscription = undefined;
+              observer.complete();
+            } else {
+              startNext(C.from(sources[index++]));
+            }
+          }
+        });
+      }
+
+      startNext(_this5);
+      return function () {
+        if (subscription) {
+          subscription.unsubscribe();
+          subscription = undefined;
+        }
+      };
+    });
+  };
+
+  _proto3.flatMap = function flatMap(fn) {
+    var _this6 = this;
+
+    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
+    var C = getSpecies(this);
+    return new C(function (observer) {
+      var subscriptions = [];
+
+      var outer = _this6.subscribe({
+        next: function (value) {
+          if (fn) {
+            try {
+              value = fn(value);
+            } catch (e) {
+              return observer.error(e);
+            }
+          }
+
+          var inner = C.from(value).subscribe({
+            next: function (value) {
+              observer.next(value);
+            },
+            error: function (e) {
+              observer.error(e);
+            },
+            complete: function () {
+              var i = subscriptions.indexOf(inner);
+              if (i >= 0) subscriptions.splice(i, 1);
+              completeIfDone();
+            }
+          });
+          subscriptions.push(inner);
+        },
+        error: function (e) {
+          observer.error(e);
+        },
+        complete: function () {
+          completeIfDone();
+        }
+      });
+
+      function completeIfDone() {
+        if (outer.closed && subscriptions.length === 0) observer.complete();
+      }
+
+      return function () {
+        subscriptions.forEach(function (s) {
+          return s.unsubscribe();
+        });
+        outer.unsubscribe();
+      };
+    });
+  };
+
+  _proto3[SymbolObservable] = function () {
+    return this;
+  };
+
+  Observable.from = function from(x) {
+    var C = typeof this === 'function' ? this : Observable;
+    if (x == null) throw new TypeError(x + ' is not an object');
+    var method = getMethod(x, SymbolObservable);
+
+    if (method) {
+      var observable = method.call(x);
+      if (Object(observable) !== observable) throw new TypeError(observable + ' is not an object');
+      if (isObservable(observable) && observable.constructor === C) return observable;
+      return new C(function (observer) {
+        return observable.subscribe(observer);
+      });
+    }
+
+    if (hasSymbol('iterator')) {
+      method = getMethod(x, SymbolIterator);
+
+      if (method) {
+        return new C(function (observer) {
+          enqueue(function () {
+            if (observer.closed) return;
+
+            for (var _iterator = _createForOfIteratorHelperLoose(method.call(x)), _step; !(_step = _iterator()).done;) {
+              var item = _step.value;
+              observer.next(item);
+              if (observer.closed) return;
+            }
+
+            observer.complete();
+          });
+        });
+      }
+    }
+
+    if (Array.isArray(x)) {
+      return new C(function (observer) {
+        enqueue(function () {
+          if (observer.closed) return;
+
+          for (var i = 0; i < x.length; ++i) {
+            observer.next(x[i]);
+            if (observer.closed) return;
+          }
+
+          observer.complete();
+        });
+      });
+    }
+
+    throw new TypeError(x + ' is not observable');
+  };
+
+  Observable.of = function of() {
+    for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      items[_key2] = arguments[_key2];
+    }
+
+    var C = typeof this === 'function' ? this : Observable;
+    return new C(function (observer) {
+      enqueue(function () {
+        if (observer.closed) return;
+
+        for (var i = 0; i < items.length; ++i) {
+          observer.next(items[i]);
+          if (observer.closed) return;
+        }
+
+        observer.complete();
+      });
+    });
+  };
+
+  _createClass(Observable, null, [{
+    key: SymbolSpecies,
+    get: function () {
+      return this;
+    }
+  }]);
+
+  return Observable;
+}();
+
+if (hasSymbols()) {
+  Object.defineProperty(Observable, Symbol('extensions'), {
+    value: {
+      symbol: SymbolObservable,
+      hostReportError: hostReportError
+    },
+    configurable: true
+  });
+}
+
+export { Observable };

graphql-subscription/node_modules/zen-observable-ts/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "zen-observable-ts",
+  "version": "1.2.5",
+  "description": "Thin wrapper around zen-observable and @types/zen-observable, to support ESM exports as well as CommonJS exports",
+  "license": "MIT",
+  "type": "module",
+  "main": "index.cjs",
+  "module": "module.js",
+  "types": "module.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apollographql/zen-observable-ts.git"
+  },
+  "bugs": {
+    "url": "https://github.com/apollographql/zen-observable-ts/issues"
+  },
+  "scripts": {
+    "build": "rollup -c rollup.config.js",
+    "prepare": "npm run build",
+    "pretest": "npm run build && rollup -c rollup.test.config.js",
+    "test": "mocha tests/bundle.cjs"
+  },
+  "dependencies": {
+    "zen-observable": "0.8.15"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.14.6",
+    "@babel/preset-env": "^7.14.7",
+    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-node-resolve": "^13.0.0",
+    "@rollup/plugin-typescript": "^8.2.1",
+    "@types/chai": "^4.2.14",
+    "@types/mocha": "^9.0.0",
+    "@types/node": "^17.0.32",
+    "chai": "^4.2.0",
+    "mocha": "^9.0.2",
+    "rollup": "^2.38.4",
+    "tslib": "^2.1.0",
+    "typescript": "^4.1.3"
+  }
+}

graphql-subscription/node_modules/zen-observable-ts/rollup.test.config.js

@@ -0,0 +1,14 @@
+import nodeResolve from "@rollup/plugin-node-resolve";
+import typescript from "@rollup/plugin-typescript";
+
+export default {
+  input: "./tests/index.ts",
+  output: {
+    file: "./tests/bundle.cjs",
+    format: "cjs",
+  },
+  plugins: [
+    nodeResolve(),
+    typescript(),
+  ],
+};

graphql-subscription/node_modules/zen-observable-ts/src/module.js

@@ -0,0 +1 @@
+export { Observable } from "zen-observable/esm.js";