@claudeye/linux-x64 1.0.4-beta.8 → 1.0.4-beta.9

package/assets/standalone/node_modules/@posthog/core/dist/error-tracking/parsers/chrome.mjs

@@ -0,0 +1,27 @@
+import { UNKNOWN_FUNCTION, createFrame } from "./base.mjs";
+import { extractSafariExtensionDetails } from "./safari.mjs";
+const chromeRegexNoFnName = /^\s*at (\S+?)(?::(\d+))(?::(\d+))\s*$/i;
+const chromeRegex = /^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+const chromeEvalRegex = /\((\S*)(?::(\d+))(?::(\d+))\)/;
+const chromeStackLineParser = (line, platform)=>{
+    const noFnParts = chromeRegexNoFnName.exec(line);
+    if (noFnParts) {
+        const [, filename, line, col] = noFnParts;
+        return createFrame(platform, filename, UNKNOWN_FUNCTION, +line, +col);
+    }
+    const parts = chromeRegex.exec(line);
+    if (parts) {
+        const isEval = parts[2] && 0 === parts[2].indexOf('eval');
+        if (isEval) {
+            const subMatch = chromeEvalRegex.exec(parts[2]);
+            if (subMatch) {
+                parts[2] = subMatch[1];
+                parts[3] = subMatch[2];
+                parts[4] = subMatch[3];
+            }
+        }
+        const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);
+        return createFrame(platform, filename, func, parts[3] ? +parts[3] : void 0, parts[4] ? +parts[4] : void 0);
+    }
+};
+export { chromeStackLineParser };

package/assets/standalone/node_modules/@posthog/core/dist/error-tracking/parsers/gecko.mjs

@@ -0,0 +1,24 @@
+import { UNKNOWN_FUNCTION, createFrame } from "./base.mjs";
+import { extractSafariExtensionDetails } from "./safari.mjs";
+const geckoREgex = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
+const geckoEvalRegex = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+const geckoStackLineParser = (line, platform)=>{
+    const parts = geckoREgex.exec(line);
+    if (parts) {
+        const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
+        if (isEval) {
+            const subMatch = geckoEvalRegex.exec(parts[3]);
+            if (subMatch) {
+                parts[1] = parts[1] || 'eval';
+                parts[3] = subMatch[1];
+                parts[4] = subMatch[2];
+                parts[5] = '';
+            }
+        }
+        let filename = parts[3];
+        let func = parts[1] || UNKNOWN_FUNCTION;
+        [func, filename] = extractSafariExtensionDetails(func, filename);
+        return createFrame(platform, filename, func, parts[4] ? +parts[4] : void 0, parts[5] ? +parts[5] : void 0);
+    }
+};
+export { geckoStackLineParser };

package/assets/standalone/node_modules/@posthog/core/dist/error-tracking/parsers/index.mjs

@@ -0,0 +1,47 @@
+import { UNKNOWN_FUNCTION } from "./base.mjs";
+import { chromeStackLineParser } from "./chrome.mjs";
+import { geckoStackLineParser } from "./gecko.mjs";
+import { winjsStackLineParser } from "./winjs.mjs";
+import { opera10StackLineParser, opera11StackLineParser } from "./opera.mjs";
+import { nodeStackLineParser } from "./node.mjs";
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const STACKTRACE_FRAME_LIMIT = 50;
+function reverseAndStripFrames(stack) {
+    if (!stack.length) return [];
+    const localStack = Array.from(stack);
+    localStack.reverse();
+    return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map((frame)=>({
+            ...frame,
+            filename: frame.filename || getLastStackFrame(localStack).filename,
+            function: frame.function || UNKNOWN_FUNCTION
+        }));
+}
+function getLastStackFrame(arr) {
+    return arr[arr.length - 1] || {};
+}
+function createDefaultStackParser() {
+    return createStackParser("web:javascript", chromeStackLineParser, geckoStackLineParser);
+}
+function createStackParser(platform, ...parsers) {
+    return (stack, skipFirstLines = 0)=>{
+        const frames = [];
+        const lines = stack.split('\n');
+        for(let i = skipFirstLines; i < lines.length; i++){
+            const line = lines[i];
+            if (line.length > 1024) continue;
+            const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;
+            if (!cleanedLine.match(/\S*Error: /)) {
+                for (const parser of parsers){
+                    const frame = parser(cleanedLine, platform);
+                    if (frame) {
+                        frames.push(frame);
+                        break;
+                    }
+                }
+                if (frames.length >= STACKTRACE_FRAME_LIMIT) break;
+            }
+        }
+        return reverseAndStripFrames(frames);
+    };
+}
+export { chromeStackLineParser, createDefaultStackParser, createStackParser, geckoStackLineParser, nodeStackLineParser, opera10StackLineParser, opera11StackLineParser, reverseAndStripFrames, winjsStackLineParser };

package/assets/standalone/node_modules/@posthog/core/dist/error-tracking/parsers/node.mjs

@@ -0,0 +1,65 @@
+import { UNKNOWN_FUNCTION } from "./base.mjs";
+const FILENAME_MATCH = /^\s*[-]{4,}$/;
+const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
+const nodeStackLineParser = (line, platform)=>{
+    const lineMatch = line.match(FULL_MATCH);
+    if (lineMatch) {
+        let object;
+        let method;
+        let functionName;
+        let typeName;
+        let methodName;
+        if (lineMatch[1]) {
+            functionName = lineMatch[1];
+            let methodStart = functionName.lastIndexOf('.');
+            if ('.' === functionName[methodStart - 1]) methodStart--;
+            if (methodStart > 0) {
+                object = functionName.slice(0, methodStart);
+                method = functionName.slice(methodStart + 1);
+                const objectEnd = object.indexOf('.Module');
+                if (objectEnd > 0) {
+                    functionName = functionName.slice(objectEnd + 1);
+                    object = object.slice(0, objectEnd);
+                }
+            }
+            typeName = void 0;
+        }
+        if (method) {
+            typeName = object;
+            methodName = method;
+        }
+        if ('<anonymous>' === method) {
+            methodName = void 0;
+            functionName = void 0;
+        }
+        if (void 0 === functionName) {
+            methodName = methodName || UNKNOWN_FUNCTION;
+            functionName = typeName ? `${typeName}.${methodName}` : methodName;
+        }
+        let filename = lineMatch[2]?.startsWith('file://') ? lineMatch[2].slice(7) : lineMatch[2];
+        const isNative = 'native' === lineMatch[5];
+        if (filename?.match(/\/[A-Z]:/)) filename = filename.slice(1);
+        if (!filename && lineMatch[5] && !isNative) filename = lineMatch[5];
+        return {
+            filename: filename ? decodeURI(filename) : void 0,
+            module: void 0,
+            function: functionName,
+            lineno: _parseIntOrUndefined(lineMatch[3]),
+            colno: _parseIntOrUndefined(lineMatch[4]),
+            in_app: filenameIsInApp(filename || '', isNative),
+            platform: platform
+        };
+    }
+    if (line.match(FILENAME_MATCH)) return {
+        filename: line,
+        platform: platform
+    };
+};
+function filenameIsInApp(filename, isNative = false) {
+    const isInternal = isNative || filename && !filename.startsWith('/') && !filename.match(/^[A-Z]:/) && !filename.startsWith('.') && !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//);
+    return !isInternal && void 0 !== filename && !filename.includes('node_modules/');
+}
+function _parseIntOrUndefined(input) {
+    return parseInt(input || '', 10) || void 0;
+}
+export { nodeStackLineParser };

package/assets/standalone/node_modules/@posthog/core/dist/error-tracking/parsers/opera.mjs

@@ -0,0 +1,12 @@
+import { UNKNOWN_FUNCTION, createFrame } from "./base.mjs";
+const opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i;
+const opera10StackLineParser = (line, platform)=>{
+    const parts = opera10Regex.exec(line);
+    return parts ? createFrame(platform, parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : void 0;
+};
+const opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\(.*\))? in (.*):\s*$/i;
+const opera11StackLineParser = (line, platform)=>{
+    const parts = opera11Regex.exec(line);
+    return parts ? createFrame(platform, parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : void 0;
+};
+export { opera10StackLineParser, opera11StackLineParser };

package/assets/standalone/node_modules/@posthog/core/dist/error-tracking/parsers/safari.mjs

@@ -0,0 +1,13 @@
+import { UNKNOWN_FUNCTION } from "./base.mjs";
+const extractSafariExtensionDetails = (func, filename)=>{
+    const isSafariExtension = -1 !== func.indexOf('safari-extension');
+    const isSafariWebExtension = -1 !== func.indexOf('safari-web-extension');
+    return isSafariExtension || isSafariWebExtension ? [
+        -1 !== func.indexOf('@') ? func.split('@')[0] : UNKNOWN_FUNCTION,
+        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`
+    ] : [
+        func,
+        filename
+    ];
+};
+export { extractSafariExtensionDetails };

package/assets/standalone/node_modules/@posthog/core/dist/error-tracking/parsers/winjs.mjs

@@ -0,0 +1,7 @@
+import { UNKNOWN_FUNCTION, createFrame } from "./base.mjs";
+const winjsRegex = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:[-a-z]+):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+const winjsStackLineParser = (line, platform)=>{
+    const parts = winjsRegex.exec(line);
+    return parts ? createFrame(platform, parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : void 0) : void 0;
+};
+export { winjsStackLineParser };

package/assets/standalone/node_modules/@posthog/core/dist/error-tracking/types.mjs

@@ -0,0 +1,9 @@
+const severityLevels = [
+    'fatal',
+    'error',
+    'warning',
+    'log',
+    'info',
+    'debug'
+];
+export { severityLevels };

package/assets/standalone/node_modules/@posthog/core/dist/error-tracking/utils.mjs

@@ -0,0 +1,23 @@
+class ReduceableCache {
+    constructor(_maxSize){
+        this._maxSize = _maxSize;
+        this._cache = new Map();
+    }
+    get(key) {
+        const value = this._cache.get(key);
+        if (void 0 === value) return;
+        this._cache.delete(key);
+        this._cache.set(key, value);
+        return value;
+    }
+    set(key, value) {
+        this._cache.set(key, value);
+    }
+    reduce() {
+        while(this._cache.size >= this._maxSize){
+            const value = this._cache.keys().next().value;
+            if (value) this._cache.delete(value);
+        }
+    }
+}
+export { ReduceableCache };

package/assets/standalone/node_modules/@posthog/core/dist/eventemitter.mjs

@@ -0,0 +1,18 @@
+class SimpleEventEmitter {
+    constructor(){
+        this.events = {};
+        this.events = {};
+    }
+    on(event, listener) {
+        if (!this.events[event]) this.events[event] = [];
+        this.events[event].push(listener);
+        return ()=>{
+            this.events[event] = this.events[event].filter((x)=>x !== listener);
+        };
+    }
+    emit(event, payload) {
+        for (const listener of this.events[event] || [])listener(payload);
+        for (const listener of this.events['*'] || [])listener(event, payload);
+    }
+}
+export { SimpleEventEmitter };

package/assets/standalone/node_modules/@posthog/core/dist/featureFlagUtils.mjs

@@ -0,0 +1,113 @@
+const normalizeFlagsResponse = (flagsResponse)=>{
+    if ('flags' in flagsResponse) {
+        const featureFlags = getFlagValuesFromFlags(flagsResponse.flags);
+        const featureFlagPayloads = getPayloadsFromFlags(flagsResponse.flags);
+        return {
+            ...flagsResponse,
+            featureFlags,
+            featureFlagPayloads
+        };
+    }
+    {
+        const featureFlags = flagsResponse.featureFlags ?? {};
+        const featureFlagPayloads = Object.fromEntries(Object.entries(flagsResponse.featureFlagPayloads || {}).map(([k, v])=>[
+                k,
+                parsePayload(v)
+            ]));
+        const flags = Object.fromEntries(Object.entries(featureFlags).map(([key, value])=>[
+                key,
+                getFlagDetailFromFlagAndPayload(key, value, featureFlagPayloads[key])
+            ]));
+        return {
+            ...flagsResponse,
+            featureFlags,
+            featureFlagPayloads,
+            flags
+        };
+    }
+};
+function getFlagDetailFromFlagAndPayload(key, value, payload) {
+    return {
+        key: key,
+        enabled: 'string' == typeof value ? true : value,
+        variant: 'string' == typeof value ? value : void 0,
+        reason: void 0,
+        metadata: {
+            id: void 0,
+            version: void 0,
+            payload: payload ? JSON.stringify(payload) : void 0,
+            description: void 0
+        }
+    };
+}
+const getFlagValuesFromFlags = (flags)=>Object.fromEntries(Object.entries(flags ?? {}).map(([key, detail])=>[
+            key,
+            getFeatureFlagValue(detail)
+        ]).filter(([, value])=>void 0 !== value));
+const getPayloadsFromFlags = (flags)=>{
+    const safeFlags = flags ?? {};
+    return Object.fromEntries(Object.keys(safeFlags).filter((flag)=>{
+        const details = safeFlags[flag];
+        return details.enabled && details.metadata && void 0 !== details.metadata.payload;
+    }).map((flag)=>{
+        const payload = safeFlags[flag].metadata?.payload;
+        return [
+            flag,
+            payload ? parsePayload(payload) : void 0
+        ];
+    }));
+};
+const getFlagDetailsFromFlagsAndPayloads = (flagsResponse)=>{
+    const flags = flagsResponse.featureFlags ?? {};
+    const payloads = flagsResponse.featureFlagPayloads ?? {};
+    return Object.fromEntries(Object.entries(flags).map(([key, value])=>[
+            key,
+            {
+                key: key,
+                enabled: 'string' == typeof value ? true : value,
+                variant: 'string' == typeof value ? value : void 0,
+                reason: void 0,
+                metadata: {
+                    id: void 0,
+                    version: void 0,
+                    payload: payloads?.[key] ? JSON.stringify(payloads[key]) : void 0,
+                    description: void 0
+                }
+            }
+        ]));
+};
+const getFeatureFlagValue = (detail)=>void 0 === detail ? void 0 : detail.variant ?? detail.enabled;
+const parsePayload = (response)=>{
+    if ('string' != typeof response) return response;
+    try {
+        return JSON.parse(response);
+    } catch  {
+        return response;
+    }
+};
+const createFlagsResponseFromFlagsAndPayloads = (featureFlags, featureFlagPayloads)=>{
+    const allKeys = [
+        ...new Set([
+            ...Object.keys(featureFlags ?? {}),
+            ...Object.keys(featureFlagPayloads ?? {})
+        ])
+    ];
+    const enabledFlags = allKeys.filter((flag)=>!!featureFlags[flag] || !!featureFlagPayloads[flag]).reduce((res, key)=>(res[key] = featureFlags[key] ?? true, res), {});
+    const flagDetails = {
+        featureFlags: enabledFlags,
+        featureFlagPayloads: featureFlagPayloads ?? {}
+    };
+    return normalizeFlagsResponse(flagDetails);
+};
+const updateFlagValue = (flag, value)=>({
+        ...flag,
+        enabled: getEnabledFromValue(value),
+        variant: getVariantFromValue(value)
+    });
+function getEnabledFromValue(value) {
+    return 'string' == typeof value ? true : value;
+}
+function getVariantFromValue(value) {
+    return 'string' == typeof value ? value : void 0;
+}
+export { createFlagsResponseFromFlagsAndPayloads, getEnabledFromValue, getFeatureFlagValue, getFlagDetailsFromFlagsAndPayloads, getFlagValuesFromFlags, getPayloadsFromFlags, getVariantFromValue, normalizeFlagsResponse, parsePayload, updateFlagValue };

package/assets/standalone/node_modules/@posthog/core/dist/gzip.mjs

@@ -0,0 +1,18 @@
+function isGzipSupported() {
+    return 'CompressionStream' in globalThis;
+}
+async function gzipCompress(input, isDebug = true) {
+    try {
+        const dataStream = new Blob([
+            input
+        ], {
+            type: 'text/plain'
+        }).stream();
+        const compressedStream = dataStream.pipeThrough(new CompressionStream('gzip'));
+        return await new Response(compressedStream).blob();
+    } catch (error) {
+        if (isDebug) console.error('Failed to gzip compress data', error);
+        return null;
+    }
+}
+export { gzipCompress, isGzipSupported };

package/assets/standalone/node_modules/@posthog/core/dist/index.mjs

@@ -0,0 +1,9 @@
+import { getFeatureFlagValue } from "./featureFlagUtils.mjs";
+import { uuidv7 } from "./vendor/uuidv7.mjs";
+import { getLengthFromRules, getRequirementsHint, getValidationError } from "./surveys/validation.mjs";
+export * from "./utils/index.mjs";
+export * from "./posthog-core.mjs";
+export * from "./posthog-core-stateless.mjs";
+export * from "./types.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__error_tracking_index_mjs_b3406d6f__ from "./error-tracking/index.mjs";
+export { __WEBPACK_EXTERNAL_MODULE__error_tracking_index_mjs_b3406d6f__ as ErrorTracking, getFeatureFlagValue, getLengthFromRules, getRequirementsHint, getValidationError, uuidv7 };