Befor generating

2026-06-01 13:17:37 +02:00
parent 3383f4bf4a
commit 1aa1b5f625
6756 changed files with 649946 additions and 1 deletions
@@ -0,0 +1,95 @@
+const newline = /\r?\n/;
+const onoCall = /\bono[ @]/;
+/**
+ * Is the property lazily computed?
+ */
+export function isLazyStack(stackProp) {
+    return Boolean(stackProp &&
+        stackProp.configurable &&
+        typeof stackProp.get === "function");
+}
+/**
+ * Is the stack property writable?
+ */
+export function isWritableStack(stackProp) {
+    return Boolean(
+    // If there is no stack property, then it's writable, since assigning it will create it
+    !stackProp ||
+        stackProp.writable ||
+        typeof stackProp.set === "function");
+}
+/**
+ * Appends the original `Error.stack` property to the new Error's stack.
+ */
+export function joinStacks(newError, originalError) {
+    let newStack = popStack(newError.stack);
+    let originalStack = originalError ? originalError.stack : undefined;
+    if (newStack && originalStack) {
+        return newStack + "\n\n" + originalStack;
+    }
+    else {
+        return newStack || originalStack;
+    }
+}
+/**
+ * Calls `joinStacks` lazily, when the `Error.stack` property is accessed.
+ */
+export function lazyJoinStacks(lazyStack, newError, originalError) {
+    if (originalError) {
+        Object.defineProperty(newError, "stack", {
+            get: () => {
+                let newStack = lazyStack.get.apply(newError);
+                return joinStacks({ stack: newStack }, originalError);
+            },
+            enumerable: false,
+            configurable: true
+        });
+    }
+    else {
+        lazyPopStack(newError, lazyStack);
+    }
+}
+/**
+ * Removes Ono from the stack, so that the stack starts at the original error location
+ */
+function popStack(stack) {
+    if (stack) {
+        let lines = stack.split(newline);
+        // Find the Ono call(s) in the stack, and remove them
+        let onoStart;
+        for (let i = 0; i < lines.length; i++) {
+            let line = lines[i];
+            if (onoCall.test(line)) {
+                if (onoStart === undefined) {
+                    // We found the first Ono call in the stack trace.
+                    // There may be other subsequent Ono calls as well.
+                    onoStart = i;
+                }
+            }
+            else if (onoStart !== undefined) {
+                // We found the first non-Ono call after one or more Ono calls.
+                // So remove the Ono call lines from the stack trace
+                lines.splice(onoStart, i - onoStart);
+                break;
+            }
+        }
+        if (lines.length > 0) {
+            return lines.join("\n");
+        }
+    }
+    // If we get here, then the stack doesn't contain a call to `ono`.
+    // This may be due to minification or some optimization of the JS engine.
+    // So just return the stack as-is.
+    return stack;
+}
+/**
+ * Calls `popStack` lazily, when the `Error.stack` property is accessed.
+ */
+function lazyPopStack(error, lazyStack) {
+    Object.defineProperty(error, "stack", {
+        get: () => popStack(lazyStack.get.apply(error)),
+        enumerable: false,
+        configurable: true
+    });
+}
+//# sourceMappingURL=stack.js.map