full-json-extractor 1.0.0

package/README.md

@@ -0,0 +1,48 @@
+# Robust Top-Level JSON Extractor
+
+## Overview
+
+This library only extracts all **highest-level valid JSON objects** from noisy or malformed text streams. It is designed to handle input where JSON objects may be embedded in extra braces, log headers, or partially malformed data, while still guaranteeing that extracted objects are parseable by `JSON.parse`.
+
+This package is meant to be used with payloads under 1MB with somewhat reasonably shaped JSON data, as worst-case time complexity is O(n^3), despite pruning techniques.
+
+---
+
+## Features
+
+- Extracts multiple valid top-level JSON objects from a single string.
+- Ignores unmatched braces, extra characters, or malformed sections.
+- Works with escaped quotes inside JSON strings.
+- Returns list of jsons derived from original input.
+
+---
+
+## Installation
+
+```bash
+npm install full-json-extractor
+```
+
+---
+
+## Usage
+
+```
+import { extractJsons } from 'full-json-extractor';
+
+const rawString = `[log header] { "id": 1, "data": { "key": "value" } } more text`;
+const jsonObjects = extractJsons(rawString);
+
+console.log(jsonObjects);
+// Output: [{ id: 1, data: { key: 'value' } }]
+```
+
+---
+
+## API
+
+```
+extractJsons(input: string, limit: Limit = "none"): object[]
+```
+
+Wrapper for Internal BFS/memoization routine to find all valid JSON intervals.

package/dist/benchmark.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=benchmark.d.ts.map

package/dist/benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../src/benchmark.ts"],"names":[],"mappings":""}

package/dist/benchmark.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_perf_hooks_1 = require("node:perf_hooks");
+const node_process_1 = __importDefault(require("node:process"));
+const extractor_js_1 = require("./extractor.js");
+function generateNestedJSON(depth) {
+    let obj = { value: "test" };
+    for (let i = 0; i < depth; i++) {
+        obj = { nested: obj };
+    }
+    return obj;
+}
+function generateRawString(depth, count, sizeFactor) {
+    const jsons = [];
+    for (let i = 0; i < count; i++) {
+        const base = generateNestedJSON(depth);
+        base.padding = "x".repeat(sizeFactor);
+        jsons.push(JSON.stringify(base));
+    }
+    return jsons.join(" some text in between ");
+}
+function getMemoryUsageMB() {
+    const used = node_process_1.default.memoryUsage().heapUsed / 1024 / 1024;
+    return Math.round(used * 100) / 100;
+}
+async function runBenchmark() {
+    const depths = [1, 3, 5, 10, 20];
+    const sizes = [0, 1000, 10000, 50_000]; // padding sizes
+    const counts = [1, 5, 10, 20]; // number of JSONs per string
+    for (const depth of depths) {
+        for (const size of sizes) {
+            for (const count of counts) {
+                const input = generateRawString(depth, count, size);
+                const memBefore = getMemoryUsageMB();
+                const start = node_perf_hooks_1.performance.now();
+                const result = (0, extractor_js_1.extractJsons)(input);
+                const end = node_perf_hooks_1.performance.now();
+                const memAfter = getMemoryUsageMB();
+                console.log(`Depth=${depth}, Size=${size}, Count=${count} | Time=${(end - start).toFixed(3)} ms | ` +
+                    `MemΔ=${(memAfter - memBefore).toFixed(3)} MB | OutputLen=${JSON.stringify(result).length}`);
+            }
+        }
+    }
+}
+runBenchmark();
+//# sourceMappingURL=benchmark.js.map

package/dist/benchmark.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.js","sourceRoot":"","sources":["../src/benchmark.ts"],"names":[],"mappings":";;;;;AAAA,qDAA8C;AAC9C,gEAAmC;AACnC,iDAA8C;AAE9C,SAAS,kBAAkB,CAAC,KAAa;IACvC,IAAI,GAAG,GAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IACjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/B,GAAG,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IACxB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,iBAAiB,CACxB,KAAa,EACb,KAAa,EACb,UAAkB;IAElB,MAAM,KAAK,GAAG,EAAE,CAAC;IACjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/B,MAAM,IAAI,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;QACtC,IAAY,CAAC,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAC/C,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;IACnC,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;AAC9C,CAAC;AAED,SAAS,gBAAgB;IACvB,MAAM,IAAI,GAAG,sBAAO,CAAC,WAAW,EAAE,CAAC,QAAQ,GAAG,IAAI,GAAG,IAAI,CAAC;IAC1D,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AACtC,CAAC;AAED,KAAK,UAAU,YAAY;IACzB,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACjC,MAAM,KAAK,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,gBAAgB;IACxD,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,6BAA6B;IAE5D,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;gBAC3B,MAAM,KAAK,GAAG,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;gBAEpD,MAAM,SAAS,GAAG,gBAAgB,EAAE,CAAC;gBACrC,MAAM,KAAK,GAAG,6BAAW,CAAC,GAAG,EAAE,CAAC;gBAEhC,MAAM,MAAM,GAAG,IAAA,2BAAY,EAAC,KAAK,CAAC,CAAC;gBAEnC,MAAM,GAAG,GAAG,6BAAW,CAAC,GAAG,EAAE,CAAC;gBAC9B,MAAM,QAAQ,GAAG,gBAAgB,EAAE,CAAC;gBAEpC,OAAO,CAAC,GAAG,CACT,SAAS,KAAK,UAAU,IAAI,WAAW,KAAK,WAAW,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ;oBACrF,QAAQ,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,mBAAmB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAC9F,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED,YAAY,EAAE,CAAC"}

package/dist/extractor.d.ts

@@ -0,0 +1,10 @@
+import { Limit } from "./interfaces";
+/**
+ * Extracts json objects from a given input string
+ * @param input input string
+ * @param limit Sets pre-check behavior. If set to 'log2', method will terminate pre-check after reaching log2(n) characters. Useful for malformed data i.e. many {}
+ * Else, will do a O(n) scan to coarsely validate brace matches. Useful for many json objects (i.e. early termination)
+ * @returns
+ */
+export declare function extractJsons(input: string, limit?: Limit): object[];
+//# sourceMappingURL=extractor.d.ts.map

package/dist/extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../src/extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,EAEN,MAAM,cAAc,CAAC;AAgMtB;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,GAAE,KAAc,GAAG,MAAM,EAAE,CAW3E"}

package/dist/extractor.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractJsons = extractJsons;
+const queue_1 = require("./queue");
+const interval_tree_1d_1 = __importDefault(require("interval-tree-1d"));
+const LBRACE = "{";
+const RBRACE = "}";
+class JsonParseError extends Error {
+}
+function convertMemoPositionToKey(memoPosition) {
+    return `${memoPosition.left}-${memoPosition.right}`;
+}
+function generateBracesPrefixAndSufix(input) {
+    const prefix = [];
+    const suffix = [];
+    const braceCounter = new Map();
+    for (let i = 0; i < input.length; i++) {
+        if (input[i] == LBRACE) {
+            prefix.push(i);
+            braceCounter.set(i, prefix.length - suffix.length);
+        }
+        else if (input[i] == RBRACE) {
+            suffix.push(i);
+            braceCounter.set(i, prefix.length - suffix.length);
+        }
+    }
+    return {
+        prefix,
+        suffix,
+    };
+}
+function queryIntervalSync(tree, low, high) {
+    let intervalExists = false;
+    tree.queryInterval(low, high, (interval) => {
+        const [left, right] = interval;
+        if (left < low && high < right) {
+            intervalExists = true;
+            return;
+        }
+    });
+    return intervalExists;
+}
+/**
+ * Coarse pre-check to filter out invalid json candidates. Short circuits if >1 json candidates exist in slice
+ *
+ * @param input
+ * @param left
+ * @param right
+ * @returns
+ */
+function isBalancedWithOneJson(input, left, right, limit) {
+    const terminationThreshold = generateLimit(input, left, limit);
+    let braceCount = 0;
+    let inString = false;
+    let escapeNext = false;
+    let firstJsonObj = true;
+    for (let i = left; i <= right; i++) {
+        if (i >= terminationThreshold) {
+            return true;
+        }
+        const char = input[i];
+        if (escapeNext) {
+            escapeNext = false;
+            continue;
+        }
+        if (char === "\\") {
+            escapeNext = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === LBRACE) {
+            braceCount++;
+        }
+        else if (char === RBRACE) {
+            braceCount--;
+        }
+        if (braceCount < 0) {
+            return false;
+        }
+        if (braceCount === 0) {
+            if (!firstJsonObj) {
+                return false;
+            }
+            firstJsonObj = !firstJsonObj;
+        }
+    }
+    return braceCount === 0;
+}
+/**
+ * Uses a Set to memoize brace locations, a Queue to process candidates top-down and uses an interval tree
+ * to detect already validated json ranges. Attempts
+ * @param braceLocations
+ * @param input
+ * @returns
+ */
+function findValidJsons({ prefix, suffix }, input, limit) {
+    const tree = (0, interval_tree_1d_1.default)();
+    const startingPosition = {
+        left: 0,
+        right: suffix.length - 1,
+    };
+    const queue = new queue_1.Queue(startingPosition);
+    const memo = new Set([convertMemoPositionToKey(startingPosition)]);
+    const jsons = [];
+    while (queue.length()) {
+        const { left: leftIndex, right: rightIndex } = queue.dequeue();
+        const leftPosition = prefix[leftIndex];
+        const rightPosition = suffix[rightIndex];
+        if (rightPosition < leftPosition ||
+            queryIntervalSync(tree, leftPosition, rightPosition)) {
+            continue;
+        }
+        try {
+            if (isBalancedWithOneJson(input, leftPosition, rightPosition, limit)) {
+                jsons.push(JSON.parse(input.slice(leftPosition, rightPosition + 1)));
+                tree.insert([leftPosition, rightPosition]);
+                continue;
+            }
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError)) {
+                throw error;
+            }
+        }
+        const positions = [
+            {
+                left: leftIndex,
+                right: rightIndex - 1 >= 0 ? rightIndex - 1 : rightIndex,
+            },
+            {
+                left: leftIndex + 1 < prefix.length ? leftIndex + 1 : leftIndex,
+                right: rightIndex,
+            },
+        ];
+        for (const position of positions) {
+            const key = convertMemoPositionToKey(position);
+            if (!memo.has(key)) {
+                queue.enqueue(position);
+                memo.add(key);
+            }
+        }
+    }
+    return jsons;
+}
+function generateLimit(input, left, limit) {
+    switch (limit) {
+        case "log2":
+            return left + Math.ceil(Math.log2(input.length));
+        case "none":
+            return input.length;
+        default:
+            throw new JsonParseError("unknown limit type provided");
+    }
+}
+/**
+ * Extracts json objects from a given input string
+ * @param input input string
+ * @param limit Sets pre-check behavior. If set to 'log2', method will terminate pre-check after reaching log2(n) characters. Useful for malformed data i.e. many {}
+ * Else, will do a O(n) scan to coarsely validate brace matches. Useful for many json objects (i.e. early termination)
+ * @returns
+ */
+function extractJsons(input, limit = "none") {
+    if (!input?.length) {
+        return [];
+    }
+    const locations = generateBracesPrefixAndSufix(input);
+    if (!locations.prefix.length || !locations.suffix.length) {
+        return [];
+    }
+    return findValidJsons(locations, input, limit);
+}
+//# sourceMappingURL=extractor.js.map

package/dist/extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.js","sourceRoot":"","sources":["../src/extractor.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./extractor";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./extractor"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B"}

package/dist/interfaces.d.ts

@@ -0,0 +1,34 @@
+export type Interval = [number, number];
+interface IntervalTreeNode {
+    mid: number;
+    left: IntervalTreeNode | null;
+    right: IntervalTreeNode | null;
+    leftPoints: Interval[];
+    rightPoints: Interval[];
+    count: number;
+    intervals(result?: Interval[]): Interval[];
+    insert(interval: Interval): void;
+    remove(interval: Interval): number;
+    queryPoint(x: number, cb: (interval: Interval) => any): any;
+    queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
+}
+export interface IntervalTreeType {
+    root: IntervalTreeNode | null;
+    insert(interval: Interval): void;
+    remove(interval: Interval): boolean;
+    queryPoint(x: number, cb: (interval: Interval) => any): any;
+    queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
+    readonly count: number;
+    readonly intervals: Interval[];
+}
+export interface MemoPosition {
+    readonly left: number;
+    readonly right: number;
+}
+export interface BraceLocationInfo {
+    readonly prefix: number[];
+    readonly suffix: number[];
+}
+export type Limit = "log2" | "none";
+export {};
+//# sourceMappingURL=interfaces.d.ts.map

package/dist/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAExC,UAAU,gBAAgB;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC/B,UAAU,EAAE,QAAQ,EAAE,CAAC;IACvB,WAAW,EAAE,QAAQ,EAAE,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,CAAC;IAC3C,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IACjC,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAC;IACnC,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,GAAG,GAAG,GAAG,CAAC;IAC5D,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,GAAG,GAAG,GAAG,CAAC;CAC7E;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC9B,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IACjC,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC;IACpC,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,GAAG,GAAG,GAAG,CAAC;IAC5D,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,GAAG,GAAG,GAAG,CAAC;IAC5E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,QAAQ,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC"}

package/dist/interfaces.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interfaces.js.map

package/dist/interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":""}

package/dist/queue.d.ts

@@ -0,0 +1,10 @@
+export declare class Queue<T> {
+    private popQueue;
+    private pushQueue;
+    constructor(...value: T[]);
+    private migratePushToPopQueue;
+    enqueue(...value: T[]): void;
+    dequeue(): T | null;
+    length(): number;
+}
+//# sourceMappingURL=queue.d.ts.map

package/dist/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../src/queue.ts"],"names":[],"mappings":"AAAA,qBAAa,KAAK,CAAC,CAAC;IAClB,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,SAAS,CAAM;gBAEX,GAAG,KAAK,EAAE,CAAC,EAAE;IAKzB,OAAO,CAAC,qBAAqB;IAMtB,OAAO,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAI5B,OAAO,IAAI,CAAC,GAAG,IAAI;IAYnB,MAAM,IAAI,MAAM;CAGxB"}

package/dist/queue.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+class Queue {
+    popQueue;
+    pushQueue;
+    constructor(...value) {
+        this.popQueue = [];
+        this.pushQueue = value;
+    }
+    migratePushToPopQueue() {
+        while (this.pushQueue.length) {
+            this.popQueue.push(this.pushQueue.pop());
+        }
+    }
+    enqueue(...value) {
+        this.pushQueue.push(...value);
+    }
+    dequeue() {
+        if (!this.popQueue.length) {
+            this.migratePushToPopQueue();
+        }
+        if (!this.popQueue.length) {
+            return null;
+        }
+        else {
+            return this.popQueue.pop();
+        }
+    }
+    length() {
+        return this.popQueue.length + this.pushQueue.length;
+    }
+}
+exports.Queue = Queue;
+//# sourceMappingURL=queue.js.map

package/dist/queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.js","sourceRoot":"","sources":["../src/queue.ts"],"names":[],"mappings":";;;AAAA,MAAa,KAAK;IACR,QAAQ,CAAM;IACd,SAAS,CAAM;IAEvB,YAAY,GAAG,KAAU;QACvB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IAEO,qBAAqB;QAC3B,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;YAC7B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,EAAG,CAAC,CAAC;QAC5C,CAAC;IACH,CAAC;IAEM,OAAO,CAAC,GAAG,KAAU;QAC1B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;IAChC,CAAC;IAEM,OAAO;QACZ,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YAC1B,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC/B,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAG,CAAC;QAC9B,CAAC;IACH,CAAC;IAEM,MAAM;QACX,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;IACtD,CAAC;CACF;AAlCD,sBAkCC"}

package/jest.config.js

@@ -0,0 +1,10 @@
+/** @type {import("jest").Config} **/
+export default {
+  preset: 'ts-jest',
+  testEnvironment: "node",
+  transform: {
+    "^.+\\.m?ts?$": ["ts-jest", {
+        useESM: true
+    }]
+  }
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "full-json-extractor",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "scripts": {
+    "clean": "rimraf dist build .cache",
+    "format": "prettier --check \"src/**/*.{js,ts,tsx,jsx,json,css,md}",
+    "format:fix": "prettier --write \"src/**/*.{js,ts,tsx,jsx,json,css,md}",
+    "build": "tsc",
+    "test": "jest",
+    "release": "npm run format && npm run test && npm run build"
+  },
+  "keywords": [
+    "json",
+    "json parse",
+    "json extract"
+  ],
+  "author": "Jonzdan",
+  "license": "ISC",
+  "description": "Brute-forces all possible highest-level json candidates with pruning to keep performance fast with reasonable payload < 1MB",
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.2.1",
+    "jest": "^30.0.5",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29.4.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "interval-tree-1d": "^1.0.4"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/__tests__/json-parser.test.ts

@@ -0,0 +1,171 @@
+import { extractJsons } from "../extractor";
+
+describe("extractJsonIntervals.test", () => {
+  it("only json, valid json, 1-depth", () => {
+    const testData = `{"sample_id": 1, "data": { "key": "xdsc" }}`;
+    const expectedData = [
+      {
+        sample_id: 1,
+        data: {
+          key: "xdsc",
+        },
+      },
+    ];
+
+    expect(extractJsons(testData)[0]).toEqual(expectedData[0]);
+  });
+
+  it("only json, invalid json, 0-depth", () => {
+    const testData = "{key: 1}";
+    expect(extractJsons(testData)).toEqual([]);
+  });
+
+  it("raw string, invalid json, 2-depth", () => {
+    const testData = '[hi] { "outer": { "inner": { key: 1 } } }';
+    expect(extractJsons(testData)).toEqual([]);
+  });
+
+  it("raw string, valid json, 1-depth", () => {
+    const testData = `[hi] {"sample_id": 1, "data": { "key": "xdsc" }}`;
+    const expectedData = [
+      {
+        sample_id: 1,
+        data: {
+          key: "xdsc",
+        },
+      },
+    ];
+
+    expect(extractJsons(testData)[0]).toEqual(expectedData[0]);
+  });
+
+  it("raw string, valid escaped json, 1-depth", () => {
+    const testData = `[hi] "{\"sample_id\": 1, \"data\": { \"key\": \"xdsc\" }}"`;
+    const expectedData = [
+      {
+        sample_id: 1,
+        data: {
+          key: "xdsc",
+        },
+      },
+    ];
+
+    expect(extractJsons(testData)[0]).toEqual(expectedData[0]);
+  });
+
+  it("raw string, valid json, 1-depth, 3 objects", () => {
+    const testData = `[hi] {"sample_id": 1, "data": { "key": "xdsc" }} {"sample_id": 2, "data": { "key": "xdsc" }} {"sample_id": 3, "data": { "key": "xdsc" }}`;
+    const expectedData = [
+      {
+        sample_id: 1,
+        data: {
+          key: "xdsc",
+        },
+      },
+      {
+        sample_id: 2,
+        data: {
+          key: "xdsc",
+        },
+      },
+      {
+        sample_id: 3,
+        data: {
+          key: "xdsc",
+        },
+      },
+    ];
+
+    const result = extractJsons(testData);
+    for (let i = 0; i < expectedData.length; i++) {
+      expect(result).toContainEqual(expectedData[i]);
+    }
+  });
+
+  it("raw string, valid json, 1-depth, 3 objects, extra {", () => {
+    const testData = `[hi] {{"sample_id": 1, "data": { "key": "xdsc" }} {"sample_id": 2, "data": { "key": "xdsc" }} {"sample_id": 3, "data": { "key": "xdsc" }}`;
+    const expectedData = [
+      {
+        sample_id: 1,
+        data: {
+          key: "xdsc",
+        },
+      },
+      {
+        sample_id: 2,
+        data: {
+          key: "xdsc",
+        },
+      },
+      {
+        sample_id: 3,
+        data: {
+          key: "xdsc",
+        },
+      },
+    ];
+
+    const result = extractJsons(testData);
+    for (let i = 0; i < expectedData.length; i++) {
+      expect(result).toContainEqual(expectedData[i]);
+    }
+  });
+
+  it("raw string, valid json, 1-depth, 3 objects, extra {, {} in string", () => {
+    const testData = `[hi] {{"sample_id": 1, "data": { "key": "x}dsc" }} {"sample_id": 2, "data": { "key": "xd{sc" }} {"sample_id": 3, "data": { "key": "xdsc" }}`;
+    const expectedData = [
+      {
+        sample_id: 1,
+        data: {
+          key: "x}dsc",
+        },
+      },
+      {
+        sample_id: 2,
+        data: {
+          key: "xd{sc",
+        },
+      },
+      {
+        sample_id: 3,
+        data: {
+          key: "xdsc",
+        },
+      },
+    ];
+
+    const result = extractJsons(testData);
+    for (let i = 0; i < expectedData.length; i++) {
+      expect(result).toContainEqual(expectedData[i]);
+    }
+  });
+
+  it("raw string, valid json, 2-depth, 150 objects, extra {, {} in string", () => {
+    const testData: string[] = [];
+    for (let i = 0; i < 150; i++) {
+      testData.push(
+        `[hi] {{"sample_id": ${i}, "data": { "key": "x}ds{c", "subdata": { "key": 2 }}}`,
+      );
+    }
+
+    const expectedData: object[] = [];
+    for (let i = 0; i < 150; i++) {
+      expectedData.push({
+        sample_id: i,
+        data: {
+          key: "x}ds{c",
+          subdata: {
+            key: 2,
+          },
+        },
+      });
+    }
+
+    const testDataString = testData.join("");
+    const result = extractJsons(testDataString);
+    expect(result.length).toEqual(150);
+    for (let i = 0; i < expectedData.length; i++) {
+      expect(result).toContainEqual(expectedData[i]);
+    }
+  });
+});

package/src/benchmark.ts

@@ -0,0 +1,59 @@
+import { performance } from "node:perf_hooks";
+import process from "node:process";
+import { extractJsons } from "./extractor.js";
+
+function generateNestedJSON(depth: number): object {
+  let obj: any = { value: "test" };
+  for (let i = 0; i < depth; i++) {
+    obj = { nested: obj };
+  }
+  return obj;
+}
+
+function generateRawString(
+  depth: number,
+  count: number,
+  sizeFactor: number,
+): string {
+  const jsons = [];
+  for (let i = 0; i < count; i++) {
+    const base = generateNestedJSON(depth);
+    (base as any).padding = "x".repeat(sizeFactor);
+    jsons.push(JSON.stringify(base));
+  }
+  return jsons.join(" some text in between ");
+}
+
+function getMemoryUsageMB(): number {
+  const used = process.memoryUsage().heapUsed / 1024 / 1024;
+  return Math.round(used * 100) / 100;
+}
+
+async function runBenchmark() {
+  const depths = [1, 3, 5, 10, 20];
+  const sizes = [0, 1000, 10000, 50_000]; // padding sizes
+  const counts = [1, 5, 10, 20]; // number of JSONs per string
+
+  for (const depth of depths) {
+    for (const size of sizes) {
+      for (const count of counts) {
+        const input = generateRawString(depth, count, size);
+
+        const memBefore = getMemoryUsageMB();
+        const start = performance.now();
+
+        const result = extractJsons(input);
+
+        const end = performance.now();
+        const memAfter = getMemoryUsageMB();
+
+        console.log(
+          `Depth=${depth}, Size=${size}, Count=${count} | Time=${(end - start).toFixed(3)} ms | ` +
+            `MemΔ=${(memAfter - memBefore).toFixed(3)} MB | OutputLen=${JSON.stringify(result).length}`,
+        );
+      }
+    }
+  }
+}
+
+runBenchmark();

package/src/extractor.ts

@@ -0,0 +1,208 @@
+import {
+  BraceLocationInfo,
+  IntervalTreeType,
+  Limit,
+  MemoPosition,
+} from "./interfaces";
+import { Queue } from "./queue";
+import IntervalTree from "interval-tree-1d";
+
+const LBRACE = "{";
+const RBRACE = "}";
+
+class JsonExtractError extends Error {}
+
+function convertMemoPositionToKey(memoPosition: MemoPosition) {
+  return `${memoPosition.left}-${memoPosition.right}`;
+}
+
+function generateBracesPrefixAndSufix(input: string): BraceLocationInfo {
+  const prefix: number[] = [];
+  const suffix: number[] = [];
+  const braceCounter: Map<number, number> = new Map();
+
+  for (let i = 0; i < input.length; i++) {
+    if (input[i] == LBRACE) {
+      prefix.push(i);
+      braceCounter.set(i, prefix.length - suffix.length);
+    } else if (input[i] == RBRACE) {
+      suffix.push(i);
+      braceCounter.set(i, prefix.length - suffix.length);
+    }
+  }
+
+  return {
+    prefix,
+    suffix,
+  };
+}
+
+function queryIntervalSync(
+  tree: IntervalTreeType,
+  low: number,
+  high: number,
+): boolean {
+  let intervalExists: boolean = false;
+  tree.queryInterval(low, high, (interval: [number, number]) => {
+    const [left, right] = interval;
+    if (left < low && high < right) {
+      intervalExists = true;
+      return;
+    }
+  });
+  return intervalExists;
+}
+
+/**
+ * Coarse pre-check to filter out invalid json candidates. Short circuits if >1 json candidates exist in slice
+ * @param input
+ * @param left
+ * @param right
+ * @returns
+ */
+function isBalancedWithOneJson(
+  input: string,
+  left: number,
+  right: number,
+  limit: Limit,
+): boolean {
+  const terminationThreshold = generateLimit(input, left, limit);
+  let braceCount = 0;
+  let inString = false;
+  let escapeNext = false;
+  let firstJsonObj = true;
+
+  for (let i = left; i <= right; i++) {
+    if (i >= terminationThreshold) {
+      return true;
+    }
+    const char = input[i];
+
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+
+    if (inString) continue;
+
+    if (char === LBRACE) {
+      braceCount++;
+    } else if (char === RBRACE) {
+      braceCount--;
+    }
+
+    if (braceCount < 0) {
+      return false;
+    }
+
+    if (braceCount === 0) {
+      if (!firstJsonObj) {
+        return false;
+      }
+      firstJsonObj = !firstJsonObj;
+    }
+  }
+
+  return braceCount === 0;
+}
+
+function findValidJsons(
+  { prefix, suffix }: BraceLocationInfo,
+  input: string,
+  limit: Limit,
+): object[] {
+  const tree = IntervalTree();
+  const startingPosition: MemoPosition = {
+    left: 0,
+    right: suffix.length - 1,
+  };
+  const queue: Queue<MemoPosition> = new Queue(startingPosition);
+  const memo = new Set<string>([convertMemoPositionToKey(startingPosition)]);
+  const jsons: object[] = [];
+
+  while (queue.length()) {
+    const { left: leftIndex, right: rightIndex } = queue.dequeue()!;
+    const leftPosition: number = prefix[leftIndex]!;
+    const rightPosition: number = suffix[rightIndex]!;
+
+    if (
+      rightPosition < leftPosition ||
+      queryIntervalSync(tree, leftPosition, rightPosition)
+    ) {
+      continue;
+    }
+
+    try {
+      if (isBalancedWithOneJson(input, leftPosition, rightPosition, limit)) {
+        jsons.push(JSON.parse(input.slice(leftPosition, rightPosition + 1)));
+        tree.insert([leftPosition, rightPosition]);
+        continue;
+      }
+    } catch (error) {
+      if (!(error instanceof SyntaxError)) {
+        throw error as JsonExtractError;
+      }
+    }
+
+    const positions: MemoPosition[] = [
+      {
+        left: leftIndex,
+        right: rightIndex - 1 >= 0 ? rightIndex - 1 : rightIndex,
+      },
+      {
+        left: leftIndex + 1 < prefix.length ? leftIndex + 1 : leftIndex,
+        right: rightIndex,
+      },
+    ];
+
+    for (const position of positions) {
+      const key = convertMemoPositionToKey(position);
+      if (!memo.has(key)) {
+        queue.enqueue(position);
+        memo.add(key);
+      }
+    }
+  }
+  return jsons;
+}
+
+function generateLimit(input: string, left: number, limit: Limit) {
+  switch (limit) {
+    case "log2":
+      return left + Math.ceil(Math.log2(input.length));
+    case "none":
+      return input.length;
+    default:
+      throw new JsonExtractError("unknown limit type provided");
+  }
+}
+
+/**
+ * Extracts json objects from a given input string
+ * @param input input string
+ * @param limit Sets pre-check behavior. If set to 'log2', method will terminate pre-check after reaching log2(n) characters. Useful for large malformed data i.e. many {} + non-json text
+ * Else, will do a O(n) scan to coarsely validate brace matches. Useful for many json objects (i.e. early termination)
+ * @returns array of JSON objects
+ */
+export function extractJsons(input: string, limit: Limit = "none"): object[] {
+  if (!input?.length) {
+    return [];
+  }
+
+  const locations = generateBracesPrefixAndSufix(input);
+  if (!locations.prefix.length || !locations.suffix.length) {
+    return [];
+  }
+
+  return findValidJsons(locations, input, limit);
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./extractor";

package/src/interfaces.ts

@@ -0,0 +1,37 @@
+export type Interval = [number, number];
+
+interface IntervalTreeNode {
+  mid: number;
+  left: IntervalTreeNode | null;
+  right: IntervalTreeNode | null;
+  leftPoints: Interval[];
+  rightPoints: Interval[];
+  count: number;
+  intervals(result?: Interval[]): Interval[];
+  insert(interval: Interval): void;
+  remove(interval: Interval): number;
+  queryPoint(x: number, cb: (interval: Interval) => any): any;
+  queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
+}
+
+export interface IntervalTreeType {
+  root: IntervalTreeNode | null;
+  insert(interval: Interval): void;
+  remove(interval: Interval): boolean;
+  queryPoint(x: number, cb: (interval: Interval) => any): any;
+  queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
+  readonly count: number;
+  readonly intervals: Interval[];
+}
+
+export interface MemoPosition {
+  readonly left: number;
+  readonly right: number;
+}
+
+export interface BraceLocationInfo {
+  readonly prefix: number[];
+  readonly suffix: number[];
+}
+
+export type Limit = "log2" | "none";

package/src/queue.ts

@@ -0,0 +1,35 @@
+export class Queue<T> {
+  private popQueue: T[];
+  private pushQueue: T[];
+
+  constructor(...value: T[]) {
+    this.popQueue = [];
+    this.pushQueue = value;
+  }
+
+  private migratePushToPopQueue(): void {
+    while (this.pushQueue.length) {
+      this.popQueue.push(this.pushQueue.pop()!);
+    }
+  }
+
+  public enqueue(...value: T[]): void {
+    this.pushQueue.push(...value);
+  }
+
+  public dequeue(): T | null {
+    if (!this.popQueue.length) {
+      this.migratePushToPopQueue();
+    }
+
+    if (!this.popQueue.length) {
+      return null;
+    } else {
+      return this.popQueue.pop()!;
+    }
+  }
+
+  public length(): number {
+    return this.popQueue.length + this.pushQueue.length;
+  }
+}

package/src/types/interval-tree-1d.d.ts

@@ -0,0 +1,31 @@
+declare module "interval-tree-1d" {
+  type Interval = [number, number];
+
+  interface IntervalTreeNode {
+    mid: number;
+    left: IntervalTreeNode | null;
+    right: IntervalTreeNode | null;
+    leftPoints: Interval[];
+    rightPoints: Interval[];
+    count: number;
+    intervals(result?: Interval[]): Interval[];
+    insert(interval: Interval): void;
+    remove(interval: Interval): number;
+    queryPoint(x: number, cb: (interval: Interval) => any): any;
+    queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
+  }
+
+  interface IntervalTree {
+    root: IntervalTreeNode | null;
+    insert(interval: Interval): void;
+    remove(interval: Interval): boolean;
+    queryPoint(x: number, cb: (interval: Interval) => any): any;
+    queryInterval(lo: number, hi: number, cb: (interval: Interval) => any): any;
+    readonly count: number;
+    readonly intervals: Interval[];
+  }
+
+  function createWrapper(intervals?: Interval[]): IntervalTree;
+
+  export = createWrapper;
+}

package/tsconfig.json

@@ -0,0 +1,54 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    "rootDir": "src",
+    "outDir": "./dist",
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "commonjs",
+    "target": "esnext",
+    "types": ["@types/jest", "@types/node"],
+    "moduleResolution": "node",
+    // For nodejs:
+    // "lib": ["esnext"],
+    // "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    "noImplicitReturns": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "esModuleInterop": true,
+    "strict": true,
+    "isolatedModules": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "paths": {
+      "src/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "src/**/__tests__"
+  ]
+}