langgraph-ui-components 0.0.3 → 0.0.6

package/dist/index.es142.js

@@ -1,43 +1,278 @@
-function deepCompareStrict(a, b) {
-  const typeofa = typeof a;
-  if (typeofa !== typeof b) {
-    return false;
-  }
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b)) {
-      return false;
+import { __exports as dist } from "./index.es143.js";
+import { __require as requireEventemitter3 } from "./index.es144.js";
+import { __require as requirePTimeout } from "./index.es145.js";
+import { __require as requirePriorityQueue } from "./index.es146.js";
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  Object.defineProperty(dist, "__esModule", { value: true });
+  const EventEmitter = requireEventemitter3();
+  const p_timeout_1 = requirePTimeout();
+  const priority_queue_1 = requirePriorityQueue();
+  const empty = () => {
+  };
+  const timeoutError = new p_timeout_1.TimeoutError();
+  class PQueue extends EventEmitter {
+    constructor(options) {
+      var _a, _b, _c, _d;
+      super();
+      this._intervalCount = 0;
+      this._intervalEnd = 0;
+      this._pendingCount = 0;
+      this._resolveEmpty = empty;
+      this._resolveIdle = empty;
+      options = Object.assign({ carryoverConcurrencyCount: false, intervalCap: Infinity, interval: 0, concurrency: Infinity, autoStart: true, queueClass: priority_queue_1.default }, options);
+      if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+        throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ""}\` (${typeof options.intervalCap})`);
+      }
+      if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+        throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ""}\` (${typeof options.interval})`);
+      }
+      this._carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+      this._isIntervalIgnored = options.intervalCap === Infinity || options.interval === 0;
+      this._intervalCap = options.intervalCap;
+      this._interval = options.interval;
+      this._queue = new options.queueClass();
+      this._queueClass = options.queueClass;
+      this.concurrency = options.concurrency;
+      this._timeout = options.timeout;
+      this._throwOnTimeout = options.throwOnTimeout === true;
+      this._isPaused = options.autoStart === false;
     }
-    const length = a.length;
-    if (length !== b.length) {
-      return false;
+    get _doesIntervalAllowAnother() {
+      return this._isIntervalIgnored || this._intervalCount < this._intervalCap;
     }
-    for (let i = 0; i < length; i++) {
-      if (!deepCompareStrict(a[i], b[i])) {
-        return false;
+    get _doesConcurrentAllowAnother() {
+      return this._pendingCount < this._concurrency;
+    }
+    _next() {
+      this._pendingCount--;
+      this._tryToStartAnother();
+      this.emit("next");
+    }
+    _resolvePromises() {
+      this._resolveEmpty();
+      this._resolveEmpty = empty;
+      if (this._pendingCount === 0) {
+        this._resolveIdle();
+        this._resolveIdle = empty;
+        this.emit("idle");
       }
     }
-    return true;
-  }
-  if (typeofa === "object") {
-    if (!a || !b) {
-      return a === b;
-    }
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    const length = aKeys.length;
-    if (length !== bKeys.length) {
+    _onResumeInterval() {
+      this._onInterval();
+      this._initializeIntervalIfNeeded();
+      this._timeoutId = void 0;
+    }
+    _isIntervalPaused() {
+      const now = Date.now();
+      if (this._intervalId === void 0) {
+        const delay = this._intervalEnd - now;
+        if (delay < 0) {
+          this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
+        } else {
+          if (this._timeoutId === void 0) {
+            this._timeoutId = setTimeout(() => {
+              this._onResumeInterval();
+            }, delay);
+          }
+          return true;
+        }
+      }
       return false;
     }
-    for (const k of aKeys) {
-      if (!deepCompareStrict(a[k], b[k])) {
+    _tryToStartAnother() {
+      if (this._queue.size === 0) {
+        if (this._intervalId) {
+          clearInterval(this._intervalId);
+        }
+        this._intervalId = void 0;
+        this._resolvePromises();
         return false;
       }
+      if (!this._isPaused) {
+        const canInitializeInterval = !this._isIntervalPaused();
+        if (this._doesIntervalAllowAnother && this._doesConcurrentAllowAnother) {
+          const job = this._queue.dequeue();
+          if (!job) {
+            return false;
+          }
+          this.emit("active");
+          job();
+          if (canInitializeInterval) {
+            this._initializeIntervalIfNeeded();
+          }
+          return true;
+        }
+      }
+      return false;
+    }
+    _initializeIntervalIfNeeded() {
+      if (this._isIntervalIgnored || this._intervalId !== void 0) {
+        return;
+      }
+      this._intervalId = setInterval(() => {
+        this._onInterval();
+      }, this._interval);
+      this._intervalEnd = Date.now() + this._interval;
+    }
+    _onInterval() {
+      if (this._intervalCount === 0 && this._pendingCount === 0 && this._intervalId) {
+        clearInterval(this._intervalId);
+        this._intervalId = void 0;
+      }
+      this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
+      this._processQueue();
+    }
+    /**
+    Executes all queued functions until it reaches the limit.
+    */
+    _processQueue() {
+      while (this._tryToStartAnother()) {
+      }
+    }
+    get concurrency() {
+      return this._concurrency;
+    }
+    set concurrency(newConcurrency) {
+      if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+        throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+      }
+      this._concurrency = newConcurrency;
+      this._processQueue();
+    }
+    /**
+    Adds a sync or async task to the queue. Always returns a promise.
+    */
+    async add(fn, options = {}) {
+      return new Promise((resolve, reject) => {
+        const run = async () => {
+          this._pendingCount++;
+          this._intervalCount++;
+          try {
+            const operation = this._timeout === void 0 && options.timeout === void 0 ? fn() : p_timeout_1.default(Promise.resolve(fn()), options.timeout === void 0 ? this._timeout : options.timeout, () => {
+              if (options.throwOnTimeout === void 0 ? this._throwOnTimeout : options.throwOnTimeout) {
+                reject(timeoutError);
+              }
+              return void 0;
+            });
+            resolve(await operation);
+          } catch (error) {
+            reject(error);
+          }
+          this._next();
+        };
+        this._queue.enqueue(run, options);
+        this._tryToStartAnother();
+        this.emit("add");
+      });
+    }
+    /**
+    	    Same as `.add()`, but accepts an array of sync or async functions.
+    
+    	    @returns A promise that resolves when all functions are resolved.
+    	    */
+    async addAll(functions, options) {
+      return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+    }
+    /**
+    Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+    */
+    start() {
+      if (!this._isPaused) {
+        return this;
+      }
+      this._isPaused = false;
+      this._processQueue();
+      return this;
+    }
+    /**
+    Put queue execution on hold.
+    */
+    pause() {
+      this._isPaused = true;
+    }
+    /**
+    Clear the queue.
+    */
+    clear() {
+      this._queue = new this._queueClass();
+    }
+    /**
+    	    Can be called multiple times. Useful if you for example add additional items at a later time.
+    
+    	    @returns A promise that settles when the queue becomes empty.
+    	    */
+    async onEmpty() {
+      if (this._queue.size === 0) {
+        return;
+      }
+      return new Promise((resolve) => {
+        const existingResolve = this._resolveEmpty;
+        this._resolveEmpty = () => {
+          existingResolve();
+          resolve();
+        };
+      });
+    }
+    /**
+    	    The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+    
+    	    @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+    	    */
+    async onIdle() {
+      if (this._pendingCount === 0 && this._queue.size === 0) {
+        return;
+      }
+      return new Promise((resolve) => {
+        const existingResolve = this._resolveIdle;
+        this._resolveIdle = () => {
+          existingResolve();
+          resolve();
+        };
+      });
+    }
+    /**
+    Size of the queue.
+    */
+    get size() {
+      return this._queue.size;
+    }
+    /**
+    	    Size of the queue, filtered by the given options.
+    
+    	    For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+    	    */
+    sizeBy(options) {
+      return this._queue.filter(options).length;
+    }
+    /**
+    Number of pending promises.
+    */
+    get pending() {
+      return this._pendingCount;
+    }
+    /**
+    Whether the queue is currently paused.
+    */
+    get isPaused() {
+      return this._isPaused;
+    }
+    get timeout() {
+      return this._timeout;
+    }
+    /**
+    Set the timeout for future operations.
+    */
+    set timeout(milliseconds) {
+      this._timeout = milliseconds;
     }
-    return true;
   }
-  return a === b;
+  dist.default = PQueue;
+  return dist;
 }
 export {
-  deepCompareStrict
+  requireDist as __require
 };
 //# sourceMappingURL=index.es142.js.map

package/dist/index.es142.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es142.js","sources":["../node_modules/.pnpm/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js"],"sourcesContent":["export function deepCompareStrict(a, b) {\n    const typeofa = typeof a;\n    if (typeofa !== typeof b) {\n        return false;\n    }\n    if (Array.isArray(a)) {\n        if (!Array.isArray(b)) {\n            return false;\n        }\n        const length = a.length;\n        if (length !== b.length) {\n            return false;\n        }\n        for (let i = 0; i < length; i++) {\n            if (!deepCompareStrict(a[i], b[i])) {\n                return false;\n            }\n        }\n        return true;\n    }\n    if (typeofa === 'object') {\n        if (!a || !b) {\n            return a === b;\n        }\n        const aKeys = Object.keys(a);\n        const bKeys = Object.keys(b);\n        const length = aKeys.length;\n        if (length !== bKeys.length) {\n            return false;\n        }\n        for (const k of aKeys) {\n            if (!deepCompareStrict(a[k], b[k])) {\n                return false;\n            }\n        }\n        return true;\n    }\n    return a === b;\n}\n"],"names":[],"mappings":"AAAO,SAAS,kBAAkB,GAAG,GAAG;AACpC,QAAM,UAAU,OAAO;AACvB,MAAI,YAAY,OAAO,GAAG;AACtB,WAAO;AAAA,EACX;AACA,MAAI,MAAM,QAAQ,CAAC,GAAG;AAClB,QAAI,CAAC,MAAM,QAAQ,CAAC,GAAG;AACnB,aAAO;AAAA,IACX;AACA,UAAM,SAAS,EAAE;AACjB,QAAI,WAAW,EAAE,QAAQ;AACrB,aAAO;AAAA,IACX;AACA,aAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC7B,UAAI,CAAC,kBAAkB,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG;AAChC,eAAO;AAAA,MACX;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AACA,MAAI,YAAY,UAAU;AACtB,QAAI,CAAC,KAAK,CAAC,GAAG;AACV,aAAO,MAAM;AAAA,IACjB;AACA,UAAM,QAAQ,OAAO,KAAK,CAAC;AAC3B,UAAM,QAAQ,OAAO,KAAK,CAAC;AAC3B,UAAM,SAAS,MAAM;AACrB,QAAI,WAAW,MAAM,QAAQ;AACzB,aAAO;AAAA,IACX;AACA,eAAW,KAAK,OAAO;AACnB,UAAI,CAAC,kBAAkB,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG;AAChC,eAAO;AAAA,MACX;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AACA,SAAO,MAAM;AACjB;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es142.js","sources":["../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/index.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst EventEmitter = require(\"eventemitter3\");\nconst p_timeout_1 = require(\"p-timeout\");\nconst priority_queue_1 = require(\"./priority-queue\");\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nconst empty = () => { };\nconst timeoutError = new p_timeout_1.TimeoutError();\n/**\nPromise queue with concurrency control.\n*/\nclass PQueue extends EventEmitter {\n    constructor(options) {\n        var _a, _b, _c, _d;\n        super();\n        this._intervalCount = 0;\n        this._intervalEnd = 0;\n        this._pendingCount = 0;\n        this._resolveEmpty = empty;\n        this._resolveIdle = empty;\n        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n        options = Object.assign({ carryoverConcurrencyCount: false, intervalCap: Infinity, interval: 0, concurrency: Infinity, autoStart: true, queueClass: priority_queue_1.default }, options);\n        if (!(typeof options.intervalCap === 'number' && options.intervalCap >= 1)) {\n            throw new TypeError(`Expected \\`intervalCap\\` to be a number from 1 and up, got \\`${(_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ''}\\` (${typeof options.intervalCap})`);\n        }\n        if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {\n            throw new TypeError(`Expected \\`interval\\` to be a finite number >= 0, got \\`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ''}\\` (${typeof options.interval})`);\n        }\n        this._carryoverConcurrencyCount = options.carryoverConcurrencyCount;\n        this._isIntervalIgnored = options.intervalCap === Infinity || options.interval === 0;\n        this._intervalCap = options.intervalCap;\n        this._interval = options.interval;\n        this._queue = new options.queueClass();\n        this._queueClass = options.queueClass;\n        this.concurrency = options.concurrency;\n        this._timeout = options.timeout;\n        this._throwOnTimeout = options.throwOnTimeout === true;\n        this._isPaused = options.autoStart === false;\n    }\n    get _doesIntervalAllowAnother() {\n        return this._isIntervalIgnored || this._intervalCount < this._intervalCap;\n    }\n    get _doesConcurrentAllowAnother() {\n        return this._pendingCount < this._concurrency;\n    }\n    _next() {\n        this._pendingCount--;\n        this._tryToStartAnother();\n        this.emit('next');\n    }\n    _resolvePromises() {\n        this._resolveEmpty();\n        this._resolveEmpty = empty;\n        if (this._pendingCount === 0) {\n            this._resolveIdle();\n            this._resolveIdle = empty;\n            this.emit('idle');\n        }\n    }\n    _onResumeInterval() {\n        this._onInterval();\n        this._initializeIntervalIfNeeded();\n        this._timeoutId = undefined;\n    }\n    _isIntervalPaused() {\n        const now = Date.now();\n        if (this._intervalId === undefined) {\n            const delay = this._intervalEnd - now;\n            if (delay < 0) {\n                // Act as the interval was done\n                // We don't need to resume it here because it will be resumed on line 160\n                this._intervalCount = (this._carryoverConcurrencyCount) ? this._pendingCount : 0;\n            }\n            else {\n                // Act as the interval is pending\n                if (this._timeoutId === undefined) {\n                    this._timeoutId = setTimeout(() => {\n                        this._onResumeInterval();\n                    }, delay);\n                }\n                return true;\n            }\n        }\n        return false;\n    }\n    _tryToStartAnother() {\n        if (this._queue.size === 0) {\n            // We can clear the interval (\"pause\")\n            // Because we can redo it later (\"resume\")\n            if (this._intervalId) {\n                clearInterval(this._intervalId);\n            }\n            this._intervalId = undefined;\n            this._resolvePromises();\n            return false;\n        }\n        if (!this._isPaused) {\n            const canInitializeInterval = !this._isIntervalPaused();\n            if (this._doesIntervalAllowAnother && this._doesConcurrentAllowAnother) {\n                const job = this._queue.dequeue();\n                if (!job) {\n                    return false;\n                }\n                this.emit('active');\n                job();\n                if (canInitializeInterval) {\n                    this._initializeIntervalIfNeeded();\n                }\n                return true;\n            }\n        }\n        return false;\n    }\n    _initializeIntervalIfNeeded() {\n        if (this._isIntervalIgnored || this._intervalId !== undefined) {\n            return;\n        }\n        this._intervalId = setInterval(() => {\n            this._onInterval();\n        }, this._interval);\n        this._intervalEnd = Date.now() + this._interval;\n    }\n    _onInterval() {\n        if (this._intervalCount === 0 && this._pendingCount === 0 && this._intervalId) {\n            clearInterval(this._intervalId);\n            this._intervalId = undefined;\n        }\n        this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;\n        this._processQueue();\n    }\n    /**\n    Executes all queued functions until it reaches the limit.\n    */\n    _processQueue() {\n        // eslint-disable-next-line no-empty\n        while (this._tryToStartAnother()) { }\n    }\n    get concurrency() {\n        return this._concurrency;\n    }\n    set concurrency(newConcurrency) {\n        if (!(typeof newConcurrency === 'number' && newConcurrency >= 1)) {\n            throw new TypeError(`Expected \\`concurrency\\` to be a number from 1 and up, got \\`${newConcurrency}\\` (${typeof newConcurrency})`);\n        }\n        this._concurrency = newConcurrency;\n        this._processQueue();\n    }\n    /**\n    Adds a sync or async task to the queue. Always returns a promise.\n    */\n    async add(fn, options = {}) {\n        return new Promise((resolve, reject) => {\n            const run = async () => {\n                this._pendingCount++;\n                this._intervalCount++;\n                try {\n                    const operation = (this._timeout === undefined && options.timeout === undefined) ? fn() : p_timeout_1.default(Promise.resolve(fn()), (options.timeout === undefined ? this._timeout : options.timeout), () => {\n                        if (options.throwOnTimeout === undefined ? this._throwOnTimeout : options.throwOnTimeout) {\n                            reject(timeoutError);\n                        }\n                        return undefined;\n                    });\n                    resolve(await operation);\n                }\n                catch (error) {\n                    reject(error);\n                }\n                this._next();\n            };\n            this._queue.enqueue(run, options);\n            this._tryToStartAnother();\n            this.emit('add');\n        });\n    }\n    /**\n    Same as `.add()`, but accepts an array of sync or async functions.\n\n    @returns A promise that resolves when all functions are resolved.\n    */\n    async addAll(functions, options) {\n        return Promise.all(functions.map(async (function_) => this.add(function_, options)));\n    }\n    /**\n    Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)\n    */\n    start() {\n        if (!this._isPaused) {\n            return this;\n        }\n        this._isPaused = false;\n        this._processQueue();\n        return this;\n    }\n    /**\n    Put queue execution on hold.\n    */\n    pause() {\n        this._isPaused = true;\n    }\n    /**\n    Clear the queue.\n    */\n    clear() {\n        this._queue = new this._queueClass();\n    }\n    /**\n    Can be called multiple times. Useful if you for example add additional items at a later time.\n\n    @returns A promise that settles when the queue becomes empty.\n    */\n    async onEmpty() {\n        // Instantly resolve if the queue is empty\n        if (this._queue.size === 0) {\n            return;\n        }\n        return new Promise(resolve => {\n            const existingResolve = this._resolveEmpty;\n            this._resolveEmpty = () => {\n                existingResolve();\n                resolve();\n            };\n        });\n    }\n    /**\n    The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.\n\n    @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.\n    */\n    async onIdle() {\n        // Instantly resolve if none pending and if nothing else is queued\n        if (this._pendingCount === 0 && this._queue.size === 0) {\n            return;\n        }\n        return new Promise(resolve => {\n            const existingResolve = this._resolveIdle;\n            this._resolveIdle = () => {\n                existingResolve();\n                resolve();\n            };\n        });\n    }\n    /**\n    Size of the queue.\n    */\n    get size() {\n        return this._queue.size;\n    }\n    /**\n    Size of the queue, filtered by the given options.\n\n    For example, this can be used to find the number of items remaining in the queue with a specific priority level.\n    */\n    sizeBy(options) {\n        // eslint-disable-next-line unicorn/no-fn-reference-in-iterator\n        return this._queue.filter(options).length;\n    }\n    /**\n    Number of pending promises.\n    */\n    get pending() {\n        return this._pendingCount;\n    }\n    /**\n    Whether the queue is currently paused.\n    */\n    get isPaused() {\n        return this._isPaused;\n    }\n    get timeout() {\n        return this._timeout;\n    }\n    /**\n    Set the timeout for future operations.\n    */\n    set timeout(milliseconds) {\n        this._timeout = milliseconds;\n    }\n}\nexports.default = PQueue;\n"],"names":["require$$0","require$$1","require$$2"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es143.js

@@ -1,27 +1,5 @@
-import { dereference } from "./index.es145.js";
-import { validate } from "./index.es226.js";
-class Validator {
-  schema;
-  draft;
-  shortCircuit;
-  lookup;
-  constructor(schema, draft = "2019-09", shortCircuit = true) {
-    this.schema = schema;
-    this.draft = draft;
-    this.shortCircuit = shortCircuit;
-    this.lookup = dereference(schema);
-  }
-  validate(instance) {
-    return validate(instance, this.schema, this.draft, this.lookup, this.shortCircuit);
-  }
-  addSchema(schema, id) {
-    if (id) {
-      schema = { ...schema, $id: id };
-    }
-    dereference(schema, this.lookup);
-  }
-}
+var dist = {};
 export {
-  Validator
+  dist as __exports
 };
 //# sourceMappingURL=index.es143.js.map

package/dist/index.es143.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es143.js","sources":["../node_modules/.pnpm/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/validator.js"],"sourcesContent":["import { dereference } from './dereference.js';\nimport { validate } from './validate.js';\nexport class Validator {\n    schema;\n    draft;\n    shortCircuit;\n    lookup;\n    constructor(schema, draft = '2019-09', shortCircuit = true) {\n        this.schema = schema;\n        this.draft = draft;\n        this.shortCircuit = shortCircuit;\n        this.lookup = dereference(schema);\n    }\n    validate(instance) {\n        return validate(instance, this.schema, this.draft, this.lookup, this.shortCircuit);\n    }\n    addSchema(schema, id) {\n        if (id) {\n            schema = { ...schema, $id: id };\n        }\n        dereference(schema, this.lookup);\n    }\n}\n"],"names":[],"mappings":";;AAEO,MAAM,UAAU;AAAA,EACnB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,YAAY,QAAQ,QAAQ,WAAW,eAAe,MAAM;AACxD,SAAK,SAAS;AACd,SAAK,QAAQ;AACb,SAAK,eAAe;AACpB,SAAK,SAAS,YAAY,MAAM;AAAA,EACpC;AAAA,EACA,SAAS,UAAU;AACf,WAAO,SAAS,UAAU,KAAK,QAAQ,KAAK,OAAO,KAAK,QAAQ,KAAK,YAAY;AAAA,EACrF;AAAA,EACA,UAAU,QAAQ,IAAI;AAClB,QAAI,IAAI;AACJ,eAAS,EAAE,GAAG,QAAQ,KAAK,GAAE;AAAA,IACjC;AACA,gBAAY,QAAQ,KAAK,MAAM;AAAA,EACnC;AACJ;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es143.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}