langgraph-ui-components 0.0.3 → 0.0.4

package/dist/index.es230.js

@@ -1,140 +1,177 @@
-import { __require as requireRe } from "./index.es231.js";
-import { __require as requireConstants } from "./index.es232.js";
-import { __require as requireSemver$1 } from "./index.es233.js";
-import { __require as requireIdentifiers } from "./index.es234.js";
-import { __require as requireParse } from "./index.es235.js";
-import { __require as requireValid } from "./index.es236.js";
-import { __require as requireClean } from "./index.es237.js";
-import { __require as requireInc } from "./index.es238.js";
-import { __require as requireDiff } from "./index.es239.js";
-import { __require as requireMajor } from "./index.es240.js";
-import { __require as requireMinor } from "./index.es241.js";
-import { __require as requirePatch } from "./index.es242.js";
-import { __require as requirePrerelease } from "./index.es243.js";
-import { __require as requireCompare } from "./index.es244.js";
-import { __require as requireRcompare } from "./index.es245.js";
-import { __require as requireCompareLoose } from "./index.es246.js";
-import { __require as requireCompareBuild } from "./index.es247.js";
-import { __require as requireSort } from "./index.es248.js";
-import { __require as requireRsort } from "./index.es249.js";
-import { __require as requireGt } from "./index.es250.js";
-import { __require as requireLt } from "./index.es251.js";
-import { __require as requireEq } from "./index.es252.js";
-import { __require as requireNeq } from "./index.es253.js";
-import { __require as requireGte } from "./index.es254.js";
-import { __require as requireLte } from "./index.es255.js";
-import { __require as requireCmp } from "./index.es256.js";
-import { __require as requireCoerce } from "./index.es257.js";
-import { __require as requireComparator } from "./index.es258.js";
-import { __require as requireRange } from "./index.es259.js";
-import { __require as requireSatisfies } from "./index.es260.js";
-import { __require as requireToComparators } from "./index.es261.js";
-import { __require as requireMaxSatisfying } from "./index.es262.js";
-import { __require as requireMinSatisfying } from "./index.es263.js";
-import { __require as requireMinVersion } from "./index.es264.js";
-import { __require as requireValid$1 } from "./index.es265.js";
-import { __require as requireOutside } from "./index.es266.js";
-import { __require as requireGtr } from "./index.es267.js";
-import { __require as requireLtr } from "./index.es268.js";
-import { __require as requireIntersects } from "./index.es269.js";
-import { __require as requireSimplify } from "./index.es270.js";
-import { __require as requireSubset } from "./index.es271.js";
-var semver;
-var hasRequiredSemver;
-function requireSemver() {
-  if (hasRequiredSemver) return semver;
-  hasRequiredSemver = 1;
-  const internalRe = requireRe();
-  const constants = requireConstants();
-  const SemVer = requireSemver$1();
-  const identifiers = requireIdentifiers();
-  const parse = requireParse();
-  const valid = requireValid();
-  const clean = requireClean();
-  const inc = requireInc();
-  const diff = requireDiff();
-  const major = requireMajor();
-  const minor = requireMinor();
-  const patch = requirePatch();
-  const prerelease = requirePrerelease();
-  const compare = requireCompare();
-  const rcompare = requireRcompare();
-  const compareLoose = requireCompareLoose();
-  const compareBuild = requireCompareBuild();
-  const sort = requireSort();
-  const rsort = requireRsort();
-  const gt = requireGt();
-  const lt = requireLt();
-  const eq = requireEq();
-  const neq = requireNeq();
-  const gte = requireGte();
-  const lte = requireLte();
-  const cmp = requireCmp();
-  const coerce = requireCoerce();
-  const Comparator = requireComparator();
-  const Range = requireRange();
-  const satisfies = requireSatisfies();
-  const toComparators = requireToComparators();
-  const maxSatisfying = requireMaxSatisfying();
-  const minSatisfying = requireMinSatisfying();
-  const minVersion = requireMinVersion();
-  const validRange = requireValid$1();
-  const outside = requireOutside();
-  const gtr = requireGtr();
-  const ltr = requireLtr();
-  const intersects = requireIntersects();
-  const simplifyRange = requireSimplify();
-  const subset = requireSubset();
-  semver = {
-    parse,
-    valid,
-    clean,
-    inc,
-    diff,
-    major,
-    minor,
-    patch,
-    prerelease,
-    compare,
-    rcompare,
-    compareLoose,
-    compareBuild,
-    sort,
-    rsort,
-    gt,
-    lt,
-    eq,
-    neq,
-    gte,
-    lte,
-    cmp,
-    coerce,
-    Comparator,
-    Range,
-    satisfies,
-    toComparators,
-    maxSatisfying,
-    minSatisfying,
-    minVersion,
-    validRange,
-    outside,
-    gtr,
-    ltr,
-    intersects,
-    simplifyRange,
-    subset,
-    SemVer,
-    re: internalRe.re,
-    src: internalRe.src,
-    tokens: internalRe.t,
-    SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
-    RELEASE_TYPES: constants.RELEASE_TYPES,
-    compareIdentifiers: identifiers.compareIdentifiers,
-    rcompareIdentifiers: identifiers.rcompareIdentifiers
+import isNetworkError from "./index.es231.js";
+function validateRetries(retries) {
+  if (typeof retries === "number") {
+    if (retries < 0) {
+      throw new TypeError("Expected `retries` to be a non-negative number.");
+    }
+    if (Number.isNaN(retries)) {
+      throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
+    }
+  } else if (retries !== void 0) {
+    throw new TypeError("Expected `retries` to be a number or Infinity.");
+  }
+}
+function validateNumberOption(name, value, { min = 0, allowInfinity = false } = {}) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new TypeError(`Expected \`${name}\` to be a number${allowInfinity ? " or Infinity" : ""}.`);
+  }
+  if (!allowInfinity && !Number.isFinite(value)) {
+    throw new TypeError(`Expected \`${name}\` to be a finite number.`);
+  }
+  if (value < min) {
+    throw new TypeError(`Expected \`${name}\` to be ≥ ${min}.`);
+  }
+}
+class AbortError extends Error {
+  constructor(message) {
+    super();
+    if (message instanceof Error) {
+      this.originalError = message;
+      ({ message } = message);
+    } else {
+      this.originalError = new Error(message);
+      this.originalError.stack = this.stack;
+    }
+    this.name = "AbortError";
+    this.message = message;
+  }
+}
+function calculateDelay(retriesConsumed, options) {
+  const attempt = Math.max(1, retriesConsumed + 1);
+  const random = options.randomize ? Math.random() + 1 : 1;
+  let timeout = Math.round(random * options.minTimeout * options.factor ** (attempt - 1));
+  timeout = Math.min(timeout, options.maxTimeout);
+  return timeout;
+}
+function calculateRemainingTime(start, max) {
+  if (!Number.isFinite(max)) {
+    return max;
+  }
+  return max - (performance.now() - start);
+}
+async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTime, options }) {
+  const normalizedError = error instanceof Error ? error : new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+  if (normalizedError instanceof AbortError) {
+    throw normalizedError.originalError;
+  }
+  const retriesLeft = Number.isFinite(options.retries) ? Math.max(0, options.retries - retriesConsumed) : options.retries;
+  const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;
+  const context = Object.freeze({
+    error: normalizedError,
+    attemptNumber,
+    retriesLeft,
+    retriesConsumed
+  });
+  await options.onFailedAttempt(context);
+  if (calculateRemainingTime(startTime, maxRetryTime) <= 0) {
+    throw normalizedError;
+  }
+  const consumeRetry = await options.shouldConsumeRetry(context);
+  const remainingTime = calculateRemainingTime(startTime, maxRetryTime);
+  if (remainingTime <= 0 || retriesLeft <= 0) {
+    throw normalizedError;
+  }
+  if (normalizedError instanceof TypeError && !isNetworkError(normalizedError)) {
+    if (consumeRetry) {
+      throw normalizedError;
+    }
+    options.signal?.throwIfAborted();
+    return false;
+  }
+  if (!await options.shouldRetry(context)) {
+    throw normalizedError;
+  }
+  if (!consumeRetry) {
+    options.signal?.throwIfAborted();
+    return false;
+  }
+  const delayTime = calculateDelay(retriesConsumed, options);
+  const finalDelay = Math.min(delayTime, remainingTime);
+  if (finalDelay > 0) {
+    await new Promise((resolve, reject) => {
+      const onAbort = () => {
+        clearTimeout(timeoutToken);
+        options.signal?.removeEventListener("abort", onAbort);
+        reject(options.signal.reason);
+      };
+      const timeoutToken = setTimeout(() => {
+        options.signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, finalDelay);
+      if (options.unref) {
+        timeoutToken.unref?.();
+      }
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  options.signal?.throwIfAborted();
+  return true;
+}
+async function pRetry(input, options = {}) {
+  options = { ...options };
+  validateRetries(options.retries);
+  if (Object.hasOwn(options, "forever")) {
+    throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
+  }
+  options.retries ??= 10;
+  options.factor ??= 2;
+  options.minTimeout ??= 1e3;
+  options.maxTimeout ??= Number.POSITIVE_INFINITY;
+  options.maxRetryTime ??= Number.POSITIVE_INFINITY;
+  options.randomize ??= false;
+  options.onFailedAttempt ??= () => {
   };
-  return semver;
+  options.shouldRetry ??= () => true;
+  options.shouldConsumeRetry ??= () => true;
+  validateNumberOption("factor", options.factor, {
+    min: 0,
+    allowInfinity: false
+  });
+  validateNumberOption("minTimeout", options.minTimeout, {
+    min: 0,
+    allowInfinity: false
+  });
+  validateNumberOption("maxTimeout", options.maxTimeout, {
+    min: 0,
+    allowInfinity: true
+  });
+  validateNumberOption("maxRetryTime", options.maxRetryTime, {
+    min: 0,
+    allowInfinity: true
+  });
+  if (!(options.factor > 0)) {
+    options.factor = 1;
+  }
+  options.signal?.throwIfAborted();
+  let attemptNumber = 0;
+  let retriesConsumed = 0;
+  const startTime = performance.now();
+  while (Number.isFinite(options.retries) ? retriesConsumed <= options.retries : true) {
+    attemptNumber++;
+    try {
+      options.signal?.throwIfAborted();
+      const result = await input(attemptNumber);
+      options.signal?.throwIfAborted();
+      return result;
+    } catch (error) {
+      if (await onAttemptFailure({
+        error,
+        attemptNumber,
+        retriesConsumed,
+        startTime,
+        options
+      })) {
+        retriesConsumed++;
+      }
+    }
+  }
+  throw new Error("Retry attempts exhausted without throwing an error.");
 }
 export {
-  requireSemver as __require
+  AbortError,
+  pRetry as default
 };
 //# sourceMappingURL=index.es230.js.map

package/dist/index.es230.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es230.js","sources":["../node_modules/.pnpm/semver@7.7.3/node_modules/semver/index.js"],"sourcesContent":["'use strict'\n\n// just pre-load all the stuff that index.js lazily exports\nconst internalRe = require('./internal/re')\nconst constants = require('./internal/constants')\nconst SemVer = require('./classes/semver')\nconst identifiers = require('./internal/identifiers')\nconst parse = require('./functions/parse')\nconst valid = require('./functions/valid')\nconst clean = require('./functions/clean')\nconst inc = require('./functions/inc')\nconst diff = require('./functions/diff')\nconst major = require('./functions/major')\nconst minor = require('./functions/minor')\nconst patch = require('./functions/patch')\nconst prerelease = require('./functions/prerelease')\nconst compare = require('./functions/compare')\nconst rcompare = require('./functions/rcompare')\nconst compareLoose = require('./functions/compare-loose')\nconst compareBuild = require('./functions/compare-build')\nconst sort = require('./functions/sort')\nconst rsort = require('./functions/rsort')\nconst gt = require('./functions/gt')\nconst lt = require('./functions/lt')\nconst eq = require('./functions/eq')\nconst neq = require('./functions/neq')\nconst gte = require('./functions/gte')\nconst lte = require('./functions/lte')\nconst cmp = require('./functions/cmp')\nconst coerce = require('./functions/coerce')\nconst Comparator = require('./classes/comparator')\nconst Range = require('./classes/range')\nconst satisfies = require('./functions/satisfies')\nconst toComparators = require('./ranges/to-comparators')\nconst maxSatisfying = require('./ranges/max-satisfying')\nconst minSatisfying = require('./ranges/min-satisfying')\nconst minVersion = require('./ranges/min-version')\nconst validRange = require('./ranges/valid')\nconst outside = require('./ranges/outside')\nconst gtr = require('./ranges/gtr')\nconst ltr = require('./ranges/ltr')\nconst intersects = require('./ranges/intersects')\nconst simplifyRange = require('./ranges/simplify')\nconst subset = require('./ranges/subset')\nmodule.exports = {\n  parse,\n  valid,\n  clean,\n  inc,\n  diff,\n  major,\n  minor,\n  patch,\n  prerelease,\n  compare,\n  rcompare,\n  compareLoose,\n  compareBuild,\n  sort,\n  rsort,\n  gt,\n  lt,\n  eq,\n  neq,\n  gte,\n  lte,\n  cmp,\n  coerce,\n  Comparator,\n  Range,\n  satisfies,\n  toComparators,\n  maxSatisfying,\n  minSatisfying,\n  minVersion,\n  validRange,\n  outside,\n  gtr,\n  ltr,\n  intersects,\n  simplifyRange,\n  subset,\n  SemVer,\n  re: internalRe.re,\n  src: internalRe.src,\n  tokens: internalRe.t,\n  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,\n  RELEASE_TYPES: constants.RELEASE_TYPES,\n  compareIdentifiers: identifiers.compareIdentifiers,\n  rcompareIdentifiers: identifiers.rcompareIdentifiers,\n}\n"],"names":["require$$0","require$$1","require$$2","require$$3","require$$4","require$$5","require$$6","require$$7","require$$8","require$$9","require$$10","require$$11","require$$12","require$$13","require$$14","require$$15","require$$16","require$$17","require$$18","require$$19","require$$20","require$$21","require$$22","require$$23","require$$24","require$$25","require$$26","require$$27","require$$28","require$$29","require$$30","require$$31","require$$32","require$$33","require$$34","require$$35","require$$36","require$$37","require$$38","require$$39","require$$40"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,QAAM,aAAaA,UAAA;AACnB,QAAM,YAAYC,iBAAA;AAClB,QAAM,SAASC,gBAAA;AACf,QAAM,cAAcC,mBAAA;AACpB,QAAM,QAAQC,aAAA;AACd,QAAM,QAAQC,aAAA;AACd,QAAM,QAAQC,aAAA;AACd,QAAM,MAAMC,WAAA;AACZ,QAAM,OAAOC,YAAA;AACb,QAAM,QAAQC,aAAA;AACd,QAAM,QAAQC,aAAA;AACd,QAAM,QAAQC,aAAA;AACd,QAAM,aAAaC,kBAAA;AACnB,QAAM,UAAUC,eAAA;AAChB,QAAM,WAAWC,gBAAA;AACjB,QAAM,eAAeC,oBAAA;AACrB,QAAM,eAAeC,oBAAA;AACrB,QAAM,OAAOC,YAAA;AACb,QAAM,QAAQC,aAAA;AACd,QAAM,KAAKC,UAAA;AACX,QAAM,KAAKC,UAAA;AACX,QAAM,KAAKC,UAAA;AACX,QAAM,MAAMC,WAAA;AACZ,QAAM,MAAMC,WAAA;AACZ,QAAM,MAAMC,WAAA;AACZ,QAAM,MAAMC,WAAA;AACZ,QAAM,SAASC,cAAA;AACf,QAAM,aAAaC,kBAAA;AACnB,QAAM,QAAQC,aAAA;AACd,QAAM,YAAYC,iBAAA;AAClB,QAAM,gBAAgBC,qBAAA;AACtB,QAAM,gBAAgBC,qBAAA;AACtB,QAAM,gBAAgBC,qBAAA;AACtB,QAAM,aAAaC,kBAAA;AACnB,QAAM,aAAaC,eAAA;AACnB,QAAM,UAAUC,eAAA;AAChB,QAAM,MAAMC,WAAA;AACZ,QAAM,MAAMC,WAAA;AACZ,QAAM,aAAaC,kBAAA;AACnB,QAAM,gBAAgBC,gBAAA;AACtB,QAAM,SAASC,cAAA;AACf,WAAiB;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,IAAI,WAAW;AAAA,IACf,KAAK,WAAW;AAAA,IAChB,QAAQ,WAAW;AAAA,IACnB,qBAAqB,UAAU;AAAA,IAC/B,eAAe,UAAU;AAAA,IACzB,oBAAoB,YAAY;AAAA,IAChC,qBAAqB,YAAY;AAAA,EACnC;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es230.js","sources":["../node_modules/.pnpm/langsmith@0.4.6_openai@6.16.0_zod@4.3.5_/node_modules/langsmith/dist/utils/p-retry/index.js"],"sourcesContent":["/* eslint-disable */\n// @ts-nocheck\n// p-retry code vendored to avoid import issues\n// Source: https://github.com/sindresorhus/p-retry\nimport isNetworkError from \"../is-network-error/index.js\";\nfunction validateRetries(retries) {\n    if (typeof retries === \"number\") {\n        if (retries < 0) {\n            throw new TypeError(\"Expected `retries` to be a non-negative number.\");\n        }\n        if (Number.isNaN(retries)) {\n            throw new TypeError(\"Expected `retries` to be a valid number or Infinity, got NaN.\");\n        }\n    }\n    else if (retries !== undefined) {\n        throw new TypeError(\"Expected `retries` to be a number or Infinity.\");\n    }\n}\nfunction validateNumberOption(name, value, { min = 0, allowInfinity = false } = {}) {\n    if (value === undefined) {\n        return;\n    }\n    if (typeof value !== \"number\" || Number.isNaN(value)) {\n        throw new TypeError(`Expected \\`${name}\\` to be a number${allowInfinity ? \" or Infinity\" : \"\"}.`);\n    }\n    if (!allowInfinity && !Number.isFinite(value)) {\n        throw new TypeError(`Expected \\`${name}\\` to be a finite number.`);\n    }\n    if (value < min) {\n        throw new TypeError(`Expected \\`${name}\\` to be \\u2265 ${min}.`);\n    }\n}\nexport class AbortError extends Error {\n    constructor(message) {\n        super();\n        if (message instanceof Error) {\n            this.originalError = message;\n            ({ message } = message);\n        }\n        else {\n            this.originalError = new Error(message);\n            this.originalError.stack = this.stack;\n        }\n        this.name = \"AbortError\";\n        this.message = message;\n    }\n}\nfunction calculateDelay(retriesConsumed, options) {\n    const attempt = Math.max(1, retriesConsumed + 1);\n    const random = options.randomize ? Math.random() + 1 : 1;\n    let timeout = Math.round(random * options.minTimeout * options.factor ** (attempt - 1));\n    timeout = Math.min(timeout, options.maxTimeout);\n    return timeout;\n}\nfunction calculateRemainingTime(start, max) {\n    if (!Number.isFinite(max)) {\n        return max;\n    }\n    return max - (performance.now() - start);\n}\nasync function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTime, options, }) {\n    const normalizedError = error instanceof Error\n        ? error\n        : new TypeError(`Non-error was thrown: \"${error}\". You should only throw errors.`);\n    if (normalizedError instanceof AbortError) {\n        throw normalizedError.originalError;\n    }\n    const retriesLeft = Number.isFinite(options.retries)\n        ? Math.max(0, options.retries - retriesConsumed)\n        : options.retries;\n    const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;\n    const context = Object.freeze({\n        error: normalizedError,\n        attemptNumber,\n        retriesLeft,\n        retriesConsumed,\n    });\n    await options.onFailedAttempt(context);\n    if (calculateRemainingTime(startTime, maxRetryTime) <= 0) {\n        throw normalizedError;\n    }\n    const consumeRetry = await options.shouldConsumeRetry(context);\n    const remainingTime = calculateRemainingTime(startTime, maxRetryTime);\n    if (remainingTime <= 0 || retriesLeft <= 0) {\n        throw normalizedError;\n    }\n    if (normalizedError instanceof TypeError &&\n        !isNetworkError(normalizedError)) {\n        if (consumeRetry) {\n            throw normalizedError;\n        }\n        options.signal?.throwIfAborted();\n        return false;\n    }\n    if (!(await options.shouldRetry(context))) {\n        throw normalizedError;\n    }\n    if (!consumeRetry) {\n        options.signal?.throwIfAborted();\n        return false;\n    }\n    const delayTime = calculateDelay(retriesConsumed, options);\n    const finalDelay = Math.min(delayTime, remainingTime);\n    if (finalDelay > 0) {\n        await new Promise((resolve, reject) => {\n            const onAbort = () => {\n                clearTimeout(timeoutToken);\n                options.signal?.removeEventListener(\"abort\", onAbort);\n                reject(options.signal.reason);\n            };\n            const timeoutToken = setTimeout(() => {\n                options.signal?.removeEventListener(\"abort\", onAbort);\n                resolve();\n            }, finalDelay);\n            if (options.unref) {\n                timeoutToken.unref?.();\n            }\n            options.signal?.addEventListener(\"abort\", onAbort, { once: true });\n        });\n    }\n    options.signal?.throwIfAborted();\n    return true;\n}\nexport default async function pRetry(input, options = {}) {\n    options = { ...options };\n    validateRetries(options.retries);\n    if (Object.hasOwn(options, \"forever\")) {\n        throw new Error(\"The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.\");\n    }\n    options.retries ??= 10;\n    options.factor ??= 2;\n    options.minTimeout ??= 1000;\n    options.maxTimeout ??= Number.POSITIVE_INFINITY;\n    options.maxRetryTime ??= Number.POSITIVE_INFINITY;\n    options.randomize ??= false;\n    options.onFailedAttempt ??= () => { };\n    options.shouldRetry ??= () => true;\n    options.shouldConsumeRetry ??= () => true;\n    // Validate numeric options and normalize edge cases\n    validateNumberOption(\"factor\", options.factor, {\n        min: 0,\n        allowInfinity: false,\n    });\n    validateNumberOption(\"minTimeout\", options.minTimeout, {\n        min: 0,\n        allowInfinity: false,\n    });\n    validateNumberOption(\"maxTimeout\", options.maxTimeout, {\n        min: 0,\n        allowInfinity: true,\n    });\n    validateNumberOption(\"maxRetryTime\", options.maxRetryTime, {\n        min: 0,\n        allowInfinity: true,\n    });\n    // Treat non-positive factor as 1 to avoid zero backoff or negative behavior\n    if (!(options.factor > 0)) {\n        options.factor = 1;\n    }\n    options.signal?.throwIfAborted();\n    let attemptNumber = 0;\n    let retriesConsumed = 0;\n    const startTime = performance.now();\n    while (Number.isFinite(options.retries) ? retriesConsumed <= options.retries : true) {\n        attemptNumber++;\n        try {\n            options.signal?.throwIfAborted();\n            const result = await input(attemptNumber);\n            options.signal?.throwIfAborted();\n            return result;\n        }\n        catch (error) {\n            if (await onAttemptFailure({\n                error,\n                attemptNumber,\n                retriesConsumed,\n                startTime,\n                options,\n            })) {\n                retriesConsumed++;\n            }\n        }\n    }\n    // Should not reach here, but in case it does, throw an error\n    throw new Error(\"Retry attempts exhausted without throwing an error.\");\n}\nexport function makeRetriable(function_, options) {\n    return function (...arguments_) {\n        return pRetry(() => function_.apply(this, arguments_), options);\n    };\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es231.js

@@ -1,96 +1,41 @@
-import { __module as re } from "./index.es272.js";
-import { __require as requireConstants } from "./index.es232.js";
-import { __require as requireDebug } from "./index.es273.js";
-var hasRequiredRe;
-function requireRe() {
-  if (hasRequiredRe) return re.exports;
-  hasRequiredRe = 1;
-  (function(module, exports$1) {
-    const {
-      MAX_SAFE_COMPONENT_LENGTH,
-      MAX_SAFE_BUILD_LENGTH,
-      MAX_LENGTH
-    } = requireConstants();
-    const debug = requireDebug();
-    exports$1 = module.exports = {};
-    const re2 = exports$1.re = [];
-    const safeRe = exports$1.safeRe = [];
-    const src = exports$1.src = [];
-    const safeSrc = exports$1.safeSrc = [];
-    const t = exports$1.t = {};
-    let R = 0;
-    const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
-    const safeRegexReplacements = [
-      ["\\s", 1],
-      ["\\d", MAX_LENGTH],
-      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
-    ];
-    const makeSafeRegex = (value) => {
-      for (const [token, max] of safeRegexReplacements) {
-        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
-      }
-      return value;
-    };
-    const createToken = (name, value, isGlobal) => {
-      const safe = makeSafeRegex(value);
-      const index = R++;
-      debug(name, index, value);
-      t[name] = index;
-      src[index] = value;
-      safeSrc[index] = safe;
-      re2[index] = new RegExp(value, isGlobal ? "g" : void 0);
-      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
-    };
-    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
-    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
-    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
-    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
-    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
-    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
-    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
-    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
-    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
-    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
-    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
-    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
-    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
-    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
-    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
-    createToken("GTLT", "((?:<|>)?=?)");
-    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
-    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
-    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
-    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
-    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
-    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
-    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
-    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
-    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
-    createToken("COERCERTL", src[t.COERCE], true);
-    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
-    createToken("LONETILDE", "(?:~>?)");
-    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
-    exports$1.tildeTrimReplace = "$1~";
-    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
-    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
-    createToken("LONECARET", "(?:\\^)");
-    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
-    exports$1.caretTrimReplace = "$1^";
-    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
-    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
-    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
-    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
-    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
-    exports$1.comparatorTrimReplace = "$1$2$3";
-    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
-    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
-    createToken("STAR", "(<|>)?=?\\s*\\*");
-    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
-    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
-  })(re, re.exports);
-  return re.exports;
+const objectToString = Object.prototype.toString;
+const isError = (value) => objectToString.call(value) === "[object Error]";
+const errorMessages = /* @__PURE__ */ new Set([
+  "network error",
+  // Chrome
+  "Failed to fetch",
+  // Chrome
+  "NetworkError when attempting to fetch resource.",
+  // Firefox
+  "The Internet connection appears to be offline.",
+  // Safari 16
+  "Network request failed",
+  // `cross-fetch`
+  "fetch failed",
+  // Undici (Node.js)
+  "terminated",
+  // Undici (Node.js)
+  " A network error occurred.",
+  // Bun (WebKit)
+  "Network connection lost"
+  // Cloudflare Workers (fetch)
+]);
+function isNetworkError(error) {
+  const isValid = error && isError(error) && error.name === "TypeError" && typeof error.message === "string";
+  if (!isValid) {
+    return false;
+  }
+  const { message, stack } = error;
+  if (message === "Load failed") {
+    return stack === void 0 || // Sentry adds its own stack trace to the fetch error, so also check for that
+    "__sentry_captured__" in error;
+  }
+  if (message.startsWith("error sending request for url")) {
+    return true;
+  }
+  return errorMessages.has(message);
 }
 export {
-  requireRe as __require
+  isNetworkError as default
 };
 //# sourceMappingURL=index.es231.js.map

package/dist/index.es231.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es231.js","sources":["../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/re.js"],"sourcesContent":["'use strict'\n\nconst {\n  MAX_SAFE_COMPONENT_LENGTH,\n  MAX_SAFE_BUILD_LENGTH,\n  MAX_LENGTH,\n} = require('./constants')\nconst debug = require('./debug')\nexports = module.exports = {}\n\n// The actual regexps go on exports.re\nconst re = exports.re = []\nconst safeRe = exports.safeRe = []\nconst src = exports.src = []\nconst safeSrc = exports.safeSrc = []\nconst t = exports.t = {}\nlet R = 0\n\nconst LETTERDASHNUMBER = '[a-zA-Z0-9-]'\n\n// Replace some greedy regex tokens to prevent regex dos issues. These regex are\n// used internally via the safeRe object since all inputs in this library get\n// normalized first to trim and collapse all extra whitespace. The original\n// regexes are exported for userland consumption and lower level usage. A\n// future breaking change could export the safer regex only with a note that\n// all input should have extra whitespace removed.\nconst safeRegexReplacements = [\n  ['\\\\s', 1],\n  ['\\\\d', MAX_LENGTH],\n  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],\n]\n\nconst makeSafeRegex = (value) => {\n  for (const [token, max] of safeRegexReplacements) {\n    value = value\n      .split(`${token}*`).join(`${token}{0,${max}}`)\n      .split(`${token}+`).join(`${token}{1,${max}}`)\n  }\n  return value\n}\n\nconst createToken = (name, value, isGlobal) => {\n  const safe = makeSafeRegex(value)\n  const index = R++\n  debug(name, index, value)\n  t[name] = index\n  src[index] = value\n  safeSrc[index] = safe\n  re[index] = new RegExp(value, isGlobal ? 'g' : undefined)\n  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined)\n}\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\ncreateToken('NUMERICIDENTIFIER', '0|[1-9]\\\\d*')\ncreateToken('NUMERICIDENTIFIERLOOSE', '\\\\d+')\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\ncreateToken('NONNUMERICIDENTIFIER', `\\\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`)\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\ncreateToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})\\\\.` +\n                   `(${src[t.NUMERICIDENTIFIER]})`)\n\ncreateToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\\\.` +\n                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`)\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n// Non-numberic identifiers include numberic identifiers but can be longer.\n// Therefore non-numberic identifiers must go first.\n\ncreateToken('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]\n}|${src[t.NUMERICIDENTIFIER]})`)\n\ncreateToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NONNUMERICIDENTIFIER]\n}|${src[t.NUMERICIDENTIFIERLOOSE]})`)\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\ncreateToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIER]})*))`)\n\ncreateToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]\n}(?:\\\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\ncreateToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`)\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\ncreateToken('BUILD', `(?:\\\\+(${src[t.BUILDIDENTIFIER]\n}(?:\\\\.${src[t.BUILDIDENTIFIER]})*))`)\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\ncreateToken('FULLPLAIN', `v?${src[t.MAINVERSION]\n}${src[t.PRERELEASE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('FULL', `^${src[t.FULLPLAIN]}$`)\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\ncreateToken('LOOSEPLAIN', `[v=\\\\s]*${src[t.MAINVERSIONLOOSE]\n}${src[t.PRERELEASELOOSE]}?${\n  src[t.BUILD]}?`)\n\ncreateToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)\n\ncreateToken('GTLT', '((?:<|>)?=?)')\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\ncreateToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\\\*`)\ncreateToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\\\*`)\n\ncreateToken('XRANGEPLAIN', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:\\\\.(${src[t.XRANGEIDENTIFIER]})` +\n                   `(?:${src[t.PRERELEASE]})?${\n                     src[t.BUILD]}?` +\n                   `)?)?`)\n\ncreateToken('XRANGEPLAINLOOSE', `[v=\\\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:\\\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +\n                        `(?:${src[t.PRERELEASELOOSE]})?${\n                          src[t.BUILD]}?` +\n                        `)?)?`)\n\ncreateToken('XRANGE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAIN]}$`)\ncreateToken('XRANGELOOSE', `^${src[t.GTLT]}\\\\s*${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\ncreateToken('COERCEPLAIN', `${'(^|[^\\\\d])' +\n              '(\\\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +\n              `(?:\\\\.(\\\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`)\ncreateToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\\\d])`)\ncreateToken('COERCEFULL', src[t.COERCEPLAIN] +\n              `(?:${src[t.PRERELEASE]})?` +\n              `(?:${src[t.BUILD]})?` +\n              `(?:$|[^\\\\d])`)\ncreateToken('COERCERTL', src[t.COERCE], true)\ncreateToken('COERCERTLFULL', src[t.COERCEFULL], true)\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\ncreateToken('LONETILDE', '(?:~>?)')\n\ncreateToken('TILDETRIM', `(\\\\s*)${src[t.LONETILDE]}\\\\s+`, true)\nexports.tildeTrimReplace = '$1~'\n\ncreateToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\ncreateToken('LONECARET', '(?:\\\\^)')\n\ncreateToken('CARETTRIM', `(\\\\s*)${src[t.LONECARET]}\\\\s+`, true)\nexports.caretTrimReplace = '$1^'\n\ncreateToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)\ncreateToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\ncreateToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\\\s*(${src[t.LOOSEPLAIN]})$|^$`)\ncreateToken('COMPARATOR', `^${src[t.GTLT]}\\\\s*(${src[t.FULLPLAIN]})$|^$`)\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\ncreateToken('COMPARATORTRIM', `(\\\\s*)${src[t.GTLT]\n}\\\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)\nexports.comparatorTrimReplace = '$1$2$3'\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\ncreateToken('HYPHENRANGE', `^\\\\s*(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s+-\\\\s+` +\n                   `(${src[t.XRANGEPLAIN]})` +\n                   `\\\\s*$`)\n\ncreateToken('HYPHENRANGELOOSE', `^\\\\s*(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s+-\\\\s+` +\n                        `(${src[t.XRANGEPLAINLOOSE]})` +\n                        `\\\\s*$`)\n\n// Star ranges basically just allow anything at all.\ncreateToken('STAR', '(<|>)?=?\\\\s*\\\\*')\n// >=0.0.0 is like a star\ncreateToken('GTE0', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0\\\\s*$')\ncreateToken('GTE0PRE', '^\\\\s*>=\\\\s*0\\\\.0\\\\.0-0\\\\s*$')\n"],"names":["require$$0","require$$1","exports","re"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es231.js","sources":["../node_modules/.pnpm/langsmith@0.4.6_openai@6.16.0_zod@4.3.5_/node_modules/langsmith/dist/utils/is-network-error/index.js"],"sourcesContent":["/* eslint-disable */\n// @ts-nocheck\n// is-network-error vendored to avoid import issues\n// Source: https://github.com/sindresorhus/is-network-error\nconst objectToString = Object.prototype.toString;\nconst isError = (value) => objectToString.call(value) === \"[object Error]\";\nconst errorMessages = new Set([\n    \"network error\", // Chrome\n    \"Failed to fetch\", // Chrome\n    \"NetworkError when attempting to fetch resource.\", // Firefox\n    \"The Internet connection appears to be offline.\", // Safari 16\n    \"Network request failed\", // `cross-fetch`\n    \"fetch failed\", // Undici (Node.js)\n    \"terminated\", // Undici (Node.js)\n    \" A network error occurred.\", // Bun (WebKit)\n    \"Network connection lost\", // Cloudflare Workers (fetch)\n]);\nexport default function isNetworkError(error) {\n    const isValid = error &&\n        isError(error) &&\n        error.name === \"TypeError\" &&\n        typeof error.message === \"string\";\n    if (!isValid) {\n        return false;\n    }\n    const { message, stack } = error;\n    // Safari 17+ has generic message but no stack for network errors\n    if (message === \"Load failed\") {\n        return (stack === undefined ||\n            // Sentry adds its own stack trace to the fetch error, so also check for that\n            \"__sentry_captured__\" in error);\n    }\n    // Deno network errors start with specific text\n    if (message.startsWith(\"error sending request for url\")) {\n        return true;\n    }\n    // Standard network error messages\n    return errorMessages.has(message);\n}\n"],"names":[],"mappings":"AAIA,MAAM,iBAAiB,OAAO,UAAU;AACxC,MAAM,UAAU,CAAC,UAAU,eAAe,KAAK,KAAK,MAAM;AAC1D,MAAM,gBAAgB,oBAAI,IAAI;AAAA,EAC1B;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AACJ,CAAC;AACc,SAAS,eAAe,OAAO;AAC1C,QAAM,UAAU,SACZ,QAAQ,KAAK,KACb,MAAM,SAAS,eACf,OAAO,MAAM,YAAY;AAC7B,MAAI,CAAC,SAAS;AACV,WAAO;AAAA,EACX;AACA,QAAM,EAAE,SAAS,MAAK,IAAK;AAE3B,MAAI,YAAY,eAAe;AAC3B,WAAQ,UAAU;AAAA,IAEd,yBAAyB;AAAA,EACjC;AAEA,MAAI,QAAQ,WAAW,+BAA+B,GAAG;AACrD,WAAO;AAAA,EACX;AAEA,SAAO,cAAc,IAAI,OAAO;AACpC;","x_google_ignoreList":[0]}