@ferricstore/ferricstore 0.11.11 → 0.12.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (87) hide show
  1. package/README.md +19 -1
  2. package/dist/durability-DlDCsdlo.d.cts +16 -0
  3. package/dist/durability-DplL0SbW.d.ts +16 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.cjs.map +1 -1
  6. package/dist/index.d.cts +5 -162
  7. package/dist/index.d.ts +5 -162
  8. package/dist/index.js +1 -1
  9. package/dist/index.js.map +1 -1
  10. package/dist/internal-lEEDZpPH.d.cts +4 -0
  11. package/dist/internal-lEEDZpPH.d.ts +4 -0
  12. package/dist/langgraph.cjs +1548 -0
  13. package/dist/langgraph.cjs.map +1 -0
  14. package/dist/langgraph.d.cts +158 -0
  15. package/dist/langgraph.d.ts +158 -0
  16. package/dist/langgraph.js +1522 -0
  17. package/dist/langgraph.js.map +1 -0
  18. package/dist/openai-agents.cjs +717 -0
  19. package/dist/openai-agents.cjs.map +1 -0
  20. package/dist/openai-agents.d.cts +50 -0
  21. package/dist/openai-agents.d.ts +50 -0
  22. package/dist/openai-agents.js +692 -0
  23. package/dist/openai-agents.js.map +1 -0
  24. package/dist/outcomes-BbFDp3AH.d.ts +160 -0
  25. package/dist/outcomes-DmBwnq0Y.d.cts +160 -0
  26. package/docs/agent-api/assets/hierarchy.js +1 -0
  27. package/docs/agent-api/assets/highlight.css +92 -0
  28. package/docs/agent-api/assets/icons.js +18 -0
  29. package/docs/agent-api/assets/icons.svg +1 -0
  30. package/docs/agent-api/assets/main.js +60 -0
  31. package/docs/agent-api/assets/navigation.js +1 -0
  32. package/docs/agent-api/assets/search.js +1 -0
  33. package/docs/agent-api/assets/style.css +1648 -0
  34. package/docs/agent-api/classes/langgraph.FerricStoreSaver.html +297 -0
  35. package/docs/agent-api/classes/langgraph.FerricStoreStore.html +298 -0
  36. package/docs/agent-api/classes/langgraph.LangGraphFlow.html +190 -0
  37. package/docs/agent-api/classes/langgraph.LangGraphFlowContext.html +158 -0
  38. package/docs/agent-api/classes/langgraph.LangGraphFlowRun.html +133 -0
  39. package/docs/agent-api/classes/openai-agents.FerricStoreSession.html +241 -0
  40. package/docs/agent-api/hierarchy.html +44 -0
  41. package/docs/agent-api/index.html +142 -0
  42. package/docs/agent-api/interfaces/langgraph.FerricFlowHandlerContext.html +94 -0
  43. package/docs/agent-api/interfaces/langgraph.FerricStoreCommandClient.html +77 -0
  44. package/docs/agent-api/interfaces/langgraph.FerricStoreLockOptions.html +81 -0
  45. package/docs/agent-api/interfaces/langgraph.FerricStoreSaverOptions.html +106 -0
  46. package/docs/agent-api/interfaces/langgraph.FerricStoreStoreOptions.html +98 -0
  47. package/docs/agent-api/interfaces/langgraph.InvokableLangGraph.html +83 -0
  48. package/docs/agent-api/interfaces/langgraph.LangGraphFlowOptions.html +116 -0
  49. package/docs/agent-api/interfaces/openai-agents.FerricStoreSessionOptions.html +114 -0
  50. package/docs/agent-api/interfaces/openai-agents.Session.html +208 -0
  51. package/docs/agent-api/interfaces/openai-agents.SessionHistoryRewriteAwareSession.html +230 -0
  52. package/docs/agent-api/interfaces/openai-agents.SessionHistoryTransactionAwareSession.html +237 -0
  53. package/docs/agent-api/modules/langgraph.html +44 -0
  54. package/docs/agent-api/modules/openai-agents.html +44 -0
  55. package/docs/agent-api/modules.html +35 -0
  56. package/docs/agent-api/types/langgraph.LangGraphChannelVersions.html +33 -0
  57. package/docs/agent-api/types/langgraph.LangGraphInvocationConfig.html +33 -0
  58. package/docs/agent-api/types/langgraph.LangGraphOutcomeMapper.html +50 -0
  59. package/docs/agent-api/types/langgraph.LangGraphPendingWrite.html +33 -0
  60. package/docs/agent-api/types/openai-agents.AgentInputItem.html +35 -0
  61. package/docs/agent-frameworks.md +176 -0
  62. package/docs/api/assets/highlight.css +12 -12
  63. package/docs/api/classes/ClaimHydrationError.html +2 -2
  64. package/docs/api/classes/ConnectionClosedError.html +2 -2
  65. package/docs/api/classes/FerricStoreError.html +2 -2
  66. package/docs/api/classes/FlowAlreadyExistsError.html +2 -2
  67. package/docs/api/classes/FlowBatchError.html +2 -2
  68. package/docs/api/classes/FlowNotFoundError.html +2 -2
  69. package/docs/api/classes/FlowQueryError.html +2 -2
  70. package/docs/api/classes/FlowWrongStateError.html +2 -2
  71. package/docs/api/classes/HTTPTransportError.html +2 -2
  72. package/docs/api/classes/InvalidCommandError.html +2 -2
  73. package/docs/api/classes/LeaseRenewalError.html +2 -2
  74. package/docs/api/classes/LockHeldError.html +2 -2
  75. package/docs/api/classes/LockNotOwnedError.html +2 -2
  76. package/docs/api/classes/OverloadedError.html +2 -2
  77. package/docs/api/classes/QueueCompletionError.html +2 -2
  78. package/docs/api/classes/RequestTimeoutError.html +2 -2
  79. package/docs/api/classes/RerouteError.html +2 -2
  80. package/docs/api/classes/StaleLeaseError.html +2 -2
  81. package/docs/api/classes/StalePolicyGenerationError.html +2 -2
  82. package/docs/api/index.html +37 -24
  83. package/docs/api/media/agent-frameworks.md +176 -0
  84. package/docs/api/media/langgraph.ts +23 -0
  85. package/docs/api/media/openai-agents-session.ts +13 -0
  86. package/docs/api/variables/FERRICSTORE_SDK_VERSION.html +1 -1
  87. package/package.json +43 -4
package/docs/api/classes/FlowAlreadyExistsError.html CHANGED
@@ -146,7 +146,7 @@ not capture any frames.</p>
146
146
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
147
147
  a string representing the location in the code at which
148
148
  <code>Error.captureStackTrace()</code> was called.</p>
149
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
149
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
150
150
  </code><button type="button">Copy</button></pre>
151
151
 
152
152
  <p>The first line of the trace will be prefixed with
@@ -156,7 +156,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
156
156
  generated stack trace.</p>
157
157
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
158
158
  details of error generation from the user. For instance:</p>
159
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
159
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
160
160
  </code><button type="button">Copy</button></pre>
161
161
 
162
162
  </div>
package/docs/api/classes/FlowBatchError.html CHANGED
@@ -168,7 +168,7 @@ not capture any frames.</p>
168
168
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
169
169
  a string representing the location in the code at which
170
170
  <code>Error.captureStackTrace()</code> was called.</p>
171
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
171
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
172
172
  </code><button type="button">Copy</button></pre>
173
173
 
174
174
  <p>The first line of the trace will be prefixed with
@@ -178,7 +178,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
178
178
  generated stack trace.</p>
179
179
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
180
180
  details of error generation from the user. For instance:</p>
181
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
181
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
182
182
  </code><button type="button">Copy</button></pre>
183
183
 
184
184
  </div>
package/docs/api/classes/FlowNotFoundError.html CHANGED
@@ -146,7 +146,7 @@ not capture any frames.</p>
146
146
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
147
147
  a string representing the location in the code at which
148
148
  <code>Error.captureStackTrace()</code> was called.</p>
149
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
149
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
150
150
  </code><button type="button">Copy</button></pre>
151
151
 
152
152
  <p>The first line of the trace will be prefixed with
@@ -156,7 +156,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
156
156
  generated stack trace.</p>
157
157
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
158
158
  details of error generation from the user. For instance:</p>
159
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
159
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
160
160
  </code><button type="button">Copy</button></pre>
161
161
 
162
162
  </div>
package/docs/api/classes/FlowQueryError.html CHANGED
@@ -169,7 +169,7 @@ not capture any frames.</p>
169
169
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
170
170
  a string representing the location in the code at which
171
171
  <code>Error.captureStackTrace()</code> was called.</p>
172
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
172
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
173
173
  </code><button type="button">Copy</button></pre>
174
174
 
175
175
  <p>The first line of the trace will be prefixed with
@@ -179,7 +179,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
179
179
  generated stack trace.</p>
180
180
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
181
181
  details of error generation from the user. For instance:</p>
182
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
182
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
183
183
  </code><button type="button">Copy</button></pre>
184
184
 
185
185
  </div>
package/docs/api/classes/FlowWrongStateError.html CHANGED
@@ -146,7 +146,7 @@ not capture any frames.</p>
146
146
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
147
147
  a string representing the location in the code at which
148
148
  <code>Error.captureStackTrace()</code> was called.</p>
149
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
149
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
150
150
  </code><button type="button">Copy</button></pre>
151
151
 
152
152
  <p>The first line of the trace will be prefixed with
@@ -156,7 +156,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
156
156
  generated stack trace.</p>
157
157
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
158
158
  details of error generation from the user. For instance:</p>
159
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
159
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
160
160
  </code><button type="button">Copy</button></pre>
161
161
 
162
162
  </div>
package/docs/api/classes/HTTPTransportError.html CHANGED
@@ -152,7 +152,7 @@ not capture any frames.</p>
152
152
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
153
153
  a string representing the location in the code at which
154
154
  <code>Error.captureStackTrace()</code> was called.</p>
155
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
155
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
156
156
  </code><button type="button">Copy</button></pre>
157
157
 
158
158
  <p>The first line of the trace will be prefixed with
@@ -162,7 +162,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
162
162
  generated stack trace.</p>
163
163
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
164
164
  details of error generation from the user. For instance:</p>
165
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
165
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
166
166
  </code><button type="button">Copy</button></pre>
167
167
 
168
168
  </div>
package/docs/api/classes/InvalidCommandError.html CHANGED
@@ -146,7 +146,7 @@ not capture any frames.</p>
146
146
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
147
147
  a string representing the location in the code at which
148
148
  <code>Error.captureStackTrace()</code> was called.</p>
149
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
149
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
150
150
  </code><button type="button">Copy</button></pre>
151
151
 
152
152
  <p>The first line of the trace will be prefixed with
@@ -156,7 +156,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
156
156
  generated stack trace.</p>
157
157
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
158
158
  details of error generation from the user. For instance:</p>
159
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
159
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
160
160
  </code><button type="button">Copy</button></pre>
161
161
 
162
162
  </div>
package/docs/api/classes/LeaseRenewalError.html CHANGED
@@ -113,7 +113,7 @@ not capture any frames.</p>
113
113
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
114
114
  a string representing the location in the code at which
115
115
  <code>Error.captureStackTrace()</code> was called.</p>
116
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
116
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
117
117
  </code><button type="button">Copy</button></pre>
118
118
 
119
119
  <p>The first line of the trace will be prefixed with
@@ -123,7 +123,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
123
123
  generated stack trace.</p>
124
124
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
125
125
  details of error generation from the user. For instance:</p>
126
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
126
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
127
127
  </code><button type="button">Copy</button></pre>
128
128
 
129
129
  </div>
package/docs/api/classes/LockHeldError.html CHANGED
@@ -146,7 +146,7 @@ not capture any frames.</p>
146
146
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
147
147
  a string representing the location in the code at which
148
148
  <code>Error.captureStackTrace()</code> was called.</p>
149
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
149
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
150
150
  </code><button type="button">Copy</button></pre>
151
151
 
152
152
  <p>The first line of the trace will be prefixed with
@@ -156,7 +156,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
156
156
  generated stack trace.</p>
157
157
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
158
158
  details of error generation from the user. For instance:</p>
159
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
159
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
160
160
  </code><button type="button">Copy</button></pre>
161
161
 
162
162
  </div>
package/docs/api/classes/LockNotOwnedError.html CHANGED
@@ -146,7 +146,7 @@ not capture any frames.</p>
146
146
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
147
147
  a string representing the location in the code at which
148
148
  <code>Error.captureStackTrace()</code> was called.</p>
149
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
149
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
150
150
  </code><button type="button">Copy</button></pre>
151
151
 
152
152
  <p>The first line of the trace will be prefixed with
@@ -156,7 +156,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
156
156
  generated stack trace.</p>
157
157
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
158
158
  details of error generation from the user. For instance:</p>
159
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
159
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
160
160
  </code><button type="button">Copy</button></pre>
161
161
 
162
162
  </div>
package/docs/api/classes/OverloadedError.html CHANGED
@@ -152,7 +152,7 @@ not capture any frames.</p>
152
152
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
153
153
  a string representing the location in the code at which
154
154
  <code>Error.captureStackTrace()</code> was called.</p>
155
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
155
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
156
156
  </code><button type="button">Copy</button></pre>
157
157
 
158
158
  <p>The first line of the trace will be prefixed with
@@ -162,7 +162,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
162
162
  generated stack trace.</p>
163
163
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
164
164
  details of error generation from the user. For instance:</p>
165
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
165
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
166
166
  </code><button type="button">Copy</button></pre>
167
167
 
168
168
  </div>
package/docs/api/classes/QueueCompletionError.html CHANGED
@@ -120,7 +120,7 @@ not capture any frames.</p>
120
120
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
121
121
  a string representing the location in the code at which
122
122
  <code>Error.captureStackTrace()</code> was called.</p>
123
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
123
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
124
124
  </code><button type="button">Copy</button></pre>
125
125
 
126
126
  <p>The first line of the trace will be prefixed with
@@ -130,7 +130,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
130
130
  generated stack trace.</p>
131
131
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
132
132
  details of error generation from the user. For instance:</p>
133
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
133
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
134
134
  </code><button type="button">Copy</button></pre>
135
135
 
136
136
  </div>
package/docs/api/classes/RequestTimeoutError.html CHANGED
@@ -162,7 +162,7 @@ not capture any frames.</p>
162
162
  <div class="tsd-comment tsd-typography"><p>Creates a <code>.stack</code> property on <code>targetObject</code>, which when accessed returns
163
163
  a string representing the location in the code at which
164
164
  <code>Error.captureStackTrace()</code> was called.</p>
165
- <pre><code class="js"><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">myObject</span><span class="hl-1">);</span><br/><span class="hl-4">myObject</span><span class="hl-1">.</span><span class="hl-4">stack</span><span class="hl-1">; </span><span class="hl-8">// Similar to `new Error().stack`</span>
165
+ <pre><code class="js"><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">myObject</span><span class="hl-1"> = {};</span><br/><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">myObject</span><span class="hl-1">);</span><br/><span class="hl-5">myObject</span><span class="hl-1">.</span><span class="hl-5">stack</span><span class="hl-1">; </span><span class="hl-3">// Similar to `new Error().stack`</span>
166
166
  </code><button type="button">Copy</button></pre>
167
167
 
168
168
  <p>The first line of the trace will be prefixed with
@@ -172,7 +172,7 @@ above <code>constructorOpt</code>, including <code>constructorOpt</code>, will b
172
172
  generated stack trace.</p>
173
173
  <p>The <code>constructorOpt</code> argument is useful for hiding implementation
174
174
  details of error generation from the user. For instance:</p>
175
- <pre><code class="js"><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-5">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-8">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> { </span><span class="hl-6">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-4">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">const</span><span class="hl-1"> </span><span class="hl-6">error</span><span class="hl-1"> = </span><span class="hl-5">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-4">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-4">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-8">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-4">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-4">error</span><span class="hl-1">, </span><span class="hl-4">b</span><span class="hl-1">); </span><span class="hl-8">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-3">throw</span><span class="hl-1"> </span><span class="hl-4">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
175
+ <pre><code class="js"><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">a</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">b</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">();</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-6">function</span><span class="hl-1"> </span><span class="hl-0">c</span><span class="hl-1">() {</span><br/><span class="hl-1"> </span><span class="hl-3">// Create an error without stack trace to avoid calculating the stack trace twice.</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> { </span><span class="hl-7">stackTraceLimit</span><span class="hl-1"> } = </span><span class="hl-5">Error</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-9">0</span><span class="hl-1">;</span><br/><span class="hl-1"> </span><span class="hl-6">const</span><span class="hl-1"> </span><span class="hl-7">error</span><span class="hl-1"> = </span><span class="hl-6">new</span><span class="hl-1"> </span><span class="hl-0">Error</span><span class="hl-1">();</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-5">stackTraceLimit</span><span class="hl-1"> = </span><span class="hl-5">stackTraceLimit</span><span class="hl-1">;</span><br/><br/><span class="hl-1"> </span><span class="hl-3">// Capture the stack trace above function b</span><br/><span class="hl-1"> </span><span class="hl-5">Error</span><span class="hl-1">.</span><span class="hl-0">captureStackTrace</span><span class="hl-1">(</span><span class="hl-5">error</span><span class="hl-1">, </span><span class="hl-5">b</span><span class="hl-1">); </span><span class="hl-3">// Neither function c, nor b is included in the stack trace</span><br/><span class="hl-1"> </span><span class="hl-4">throw</span><span class="hl-1"> </span><span class="hl-5">error</span><span class="hl-1">;</span><br/><span class="hl-1">}</span><br/><br/><span class="hl-0">a</span><span class="hl-1">();</span>
176
176
  </code><button type="button">Copy</button></pre>
177
177
 
178
178
  </div>