-
-
-
+
);
-}
+};
export default App;
diff --git a/src/Expressions.tsx b/src/Expressions.tsx
deleted file mode 100644
index 42bfcd8..0000000
--- a/src/Expressions.tsx
+++ /dev/null
@@ -1,71 +0,0 @@
-import React from 'react';
-
-function JsonExpressions() {
- return (
-
-
-
-
-
- JSONPath
- Description
-
-
-
-
- $
- the root object/element
-
-
- @
- the current object/element
-
-
- . or []
- child operator
-
-
- ..
- recursive descent. JSONPath borrows this syntax from E4X.
-
-
- *
- wildcard. All objects/elements regardless their names.
-
-
- []
-
- subscript operator. XPath uses it to iterate over element collections and for predicates. In
- Javascript and JSON it is the native array operator.
-
-
-
- [,]
-
- Union operator in XPath results in a combination of node sets. JSONPath allows alternate
- names or array indices as a set.
-
-
-
- [start:end:step]
- array slice operator borrowed from ES4.
-
-
- ?()
- applies a filter (script) expression.
-
-
- ()
- script expression, using the underlying script engine.
-
-
-
-
- See: JSONPath expressions - https://goessner.net/
-
-
-
- );
-}
-
-export default JsonExpressions;
diff --git a/src/sample.json b/src/assets/sample.json
similarity index 100%
rename from src/sample.json
rename to src/assets/sample.json
diff --git a/src/components/Query.tsx b/src/components/Query.tsx
new file mode 100644
index 0000000..3e493b0
--- /dev/null
+++ b/src/components/Query.tsx
@@ -0,0 +1,45 @@
+import { useJSONPath } from "@/hooks/use-jsonpath";
+import { EngineSelector } from "./engine-selector";
+import { Input } from "./ui/input";
+import { Label } from "./ui/label";
+import { cn } from "@/lib/utils";
+import { EngineDescription } from "./engine-description";
+import { useEffect, useRef } from "react";
+
+export const Query = () => {
+ const { query, setQuery, result } = useJSONPath();
+
+ const queryInputRef = useRef
(null);
+ useEffect(() => {
+ queryInputRef.current?.focus();
+ }, []);
+
+ return (
+
+
+
+ JSONPath
+
+
+
+
+
+
setQuery(e.target.value)}
+ className={cn(
+ !result.isValid &&
+ "ring-2 ring-destructive focus-visible:ring-2 focus-visible:ring-destructive"
+ )}
+ />
+
{result.error}
+
+
+
+
+ JSONPath Online Evaluator
+ {/*
+ {" "}
+ - jsonpath.com
+ */}
+
+
+
(undefined);
+
+ useEffect(() => {
+ try {
+ normalizedPathNodeRef.current = generateNormalizedPathNode(document);
+ } catch {
+ normalizedPathNodeRef.current = undefined;
+ }
+ }, [document]);
+
+ const handleEditorDidMount: OnMount = async (editor, monaco) => {
+ monaco.languages.registerHoverProvider("json", {
+ provideHover(model, position) {
+ // Hover normalized path on the document only
+ if (model.id !== editor.getModel()?.id) return undefined;
+
+ // When the document is invalid, hovers none
+ if (!normalizedPathNodeRef.current) return undefined;
+
+ // Find the smallest node that contains the position
+ const foundNode = findSmallestNode(normalizedPathNodeRef.current, {
+ line: position.lineNumber,
+ column: position.column,
+ });
+
+ if (foundNode?.path) {
+ return {
+ range: new monaco.Range(
+ foundNode?.location.start.line,
+ foundNode?.location.start.column,
+ foundNode?.location.end.line,
+ foundNode?.location.end.column
+ ),
+ contents: [
+ { value: "**Normalized Path**" },
+ {
+ value: foundNode.path,
+ },
+ ],
+ };
+ }
+
+ return undefined;
+ },
+ });
+ };
+
+ const handleOnChange = (value: string | undefined) => {
+ setDocument(value || "");
+ };
+
+ return (
+
+ RFC 9535 - JSONPath: Query Expressions for JSON
+
+
+ Parser: jsonpath-js
+
+
+ );
+ case "jsonpath-plus":
+ return (
+
+ Parser: JSONPath Plus
+
+ );
+ default:
+ engine satisfies never;
+ break;
+ }
+ };
+
+ return (
+ {getDescription()}
+ );
+};
diff --git a/src/components/engine-selector.tsx b/src/components/engine-selector.tsx
new file mode 100644
index 0000000..41c9905
--- /dev/null
+++ b/src/components/engine-selector.tsx
@@ -0,0 +1,39 @@
+import { useJSONPath } from "@/hooks/use-jsonpath";
+import { engines, parseEngine } from "@/types/engine";
+import {
+ Select,
+ SelectContent,
+ SelectItem,
+ SelectTrigger,
+ SelectValue,
+} from "./ui/select";
+
+export const EngineSelector = () => {
+ const { engine, setEngine } = useJSONPath();
+
+ return (
+
+ {
+ const newEngine = parseEngine(currentValue);
+ if (newEngine) {
+ setEngine(newEngine);
+ }
+ }}
+ >
+
+
+
+ {engines.map((engine) => (
+
+ {engine.label}
+
+ ))}
+
+
+
+ );
+};
diff --git a/src/components/external-link.tsx b/src/components/external-link.tsx
new file mode 100644
index 0000000..f5d85d6
--- /dev/null
+++ b/src/components/external-link.tsx
@@ -0,0 +1,19 @@
+import { SquareArrowOutUpRight } from "lucide-react";
+
+interface Props {
+ href: string;
+ children: React.ReactNode;
+}
+
+export const ExternalLink = ({ href, children }: Props) => {
+ return (
+
+ {children}
+
+ );
+};
diff --git a/src/components/footer/Footer.tsx b/src/components/footer/Footer.tsx
new file mode 100644
index 0000000..7fcfbde
--- /dev/null
+++ b/src/components/footer/Footer.tsx
@@ -0,0 +1,18 @@
+import { Shares } from "./shares";
+
+export const Footer = () => {
+ return (
+
+ );
+};
diff --git a/src/components/footer/Shares.tsx b/src/components/footer/Shares.tsx
new file mode 100644
index 0000000..7cfcd01
--- /dev/null
+++ b/src/components/footer/Shares.tsx
@@ -0,0 +1,47 @@
+import {
+ FacebookIcon,
+ FacebookShareButton,
+ HatenaIcon,
+ HatenaShareButton,
+ PocketIcon,
+ PocketShareButton,
+ TwitterShareButton,
+ XIcon,
+} from "react-share";
+
+const SHARE_URL = "https://jsonpath.com/";
+const SHARE_TITLE = "JSONPath Online Evaluator";
+
+export const Shares = () => {
+ return (
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Document
+
+
+
+ Evaluation Results
+
+
+
+
,
+ VariantProps {
+ asChild?: boolean;
+}
+
+const Button = React.forwardRef(
+ ({ className, variant, size, asChild = false, ...props }, ref) => {
+ const Comp = asChild ? Slot : "button";
+ return (
+ >(
+ ({ className, type, ...props }, ref) => {
+ return (
+ ,
+ React.ComponentPropsWithoutRef &
+ VariantProps
+>(({ className, ...props }, ref) => (
+ ,
+ React.ComponentPropsWithoutRef
+>(({ className, children, ...props }, ref) => (
+ span]:line-clamp-1",
+ className
+ )}
+ {...props}
+ >
+ {children}
+
+
+
+))
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName
+
+const SelectScrollUpButton = React.forwardRef<
+ React.ElementRef,
+ React.ComponentPropsWithoutRef
+>(({ className, ...props }, ref) => (
+
+
+))
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName
+
+const SelectScrollDownButton = React.forwardRef<
+ React.ElementRef,
+ React.ComponentPropsWithoutRef
+>(({ className, ...props }, ref) => (
+
+
+))
+SelectScrollDownButton.displayName =
+ SelectPrimitive.ScrollDownButton.displayName
+
+const SelectContent = React.forwardRef<
+ React.ElementRef,
+ React.ComponentPropsWithoutRef
+>(({ className, children, position = "popper", ...props }, ref) => (
+
+
+
+ {children}
+
+
+
+))
+SelectContent.displayName = SelectPrimitive.Content.displayName
+
+const SelectLabel = React.forwardRef<
+ React.ElementRef,
+ React.ComponentPropsWithoutRef
+>(({ className, ...props }, ref) => (
+ ,
+ React.ComponentPropsWithoutRef
+>(({ className, children, ...props }, ref) => (
+
+
+
+
+
+ {children}
+
+))
+SelectItem.displayName = SelectPrimitive.Item.displayName
+
+const SelectSeparator = React.forwardRef<
+ React.ElementRef,
+ React.ComponentPropsWithoutRef
+>(({ className, ...props }, ref) => (
+ ("rfc9535");
+const queryAtom = atom("$.phoneNumbers[:1].type");
+
+const documentAtom = atom(SampleJsonFile);
+const jsonDocumentAtom = atom((get) => {
+ try {
+ const jsonDocument = JSON.parse(get(documentAtom)) as JSONValue;
+ return {
+ json: jsonDocument,
+ error: undefined,
+ };
+ } catch (error) {
+ return {
+ json: undefined,
+ error: String(error),
+ };
+ }
+});
+
+const resultAtom = atom((get) => {
+ const jsonDocument = get(jsonDocumentAtom);
+ const query = get(queryAtom);
+
+ try {
+ const result = evalJsonPath(
+ get(engineAtom),
+ jsonDocument.error === undefined ? jsonDocument.json : {},
+ query
+ );
+
+ return {
+ isValid: true,
+ result,
+ error: undefined,
+ };
+ } catch (error) {
+ return {
+ isValid: false,
+ result: undefined,
+ error: String(error),
+ };
+ }
+});
+
+export const useJSONPath = () => {
+ const [engine, setEngine] = useAtom(engineAtom);
+ const [query, setQuery] = useAtom(queryAtom);
+ const [document, setDocument] = useAtom(documentAtom);
+ const jsonDocument = useAtomValue(jsonDocumentAtom);
+ const result = useAtomValue(resultAtom);
+
+ return {
+ engine,
+ setEngine,
+ query,
+ setQuery,
+ document,
+ jsonDocument,
+ setDocument,
+ result,
+ };
+};
diff --git a/src/index.css b/src/index.css
index bc0e056..0101d76 100644
--- a/src/index.css
+++ b/src/index.css
@@ -1,3 +1,7 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
/*Space out content a bit*/
body {
padding-bottom: 20px;
@@ -21,3 +25,68 @@ h3 {
.author {
margin-top: 20px;
}
+
+@layer base {
+ :root {
+ --background: 0 0% 100%;
+ --foreground: 0 0% 3.9%;
+ --card: 0 0% 100%;
+ --card-foreground: 0 0% 3.9%;
+ --popover: 0 0% 100%;
+ --popover-foreground: 0 0% 3.9%;
+ --primary: 0 0% 9%;
+ --primary-foreground: 0 0% 98%;
+ --secondary: 0 0% 96.1%;
+ --secondary-foreground: 0 0% 9%;
+ --muted: 0 0% 96.1%;
+ --muted-foreground: 0 0% 45.1%;
+ --accent: 0 0% 96.1%;
+ --accent-foreground: 0 0% 9%;
+ --destructive: 0 84.2% 60.2%;
+ --destructive-foreground: 0 0% 98%;
+ --border: 0 0% 89.8%;
+ --input: 0 0% 89.8%;
+ --ring: 0 0% 3.9%;
+ --chart-1: 12 76% 61%;
+ --chart-2: 173 58% 39%;
+ --chart-3: 197 37% 24%;
+ --chart-4: 43 74% 66%;
+ --chart-5: 27 87% 67%;
+ --radius: 0.5rem;
+ }
+ .dark {
+ --background: 0 0% 3.9%;
+ --foreground: 0 0% 98%;
+ --card: 0 0% 3.9%;
+ --card-foreground: 0 0% 98%;
+ --popover: 0 0% 3.9%;
+ --popover-foreground: 0 0% 98%;
+ --primary: 0 0% 98%;
+ --primary-foreground: 0 0% 9%;
+ --secondary: 0 0% 14.9%;
+ --secondary-foreground: 0 0% 98%;
+ --muted: 0 0% 14.9%;
+ --muted-foreground: 0 0% 63.9%;
+ --accent: 0 0% 14.9%;
+ --accent-foreground: 0 0% 98%;
+ --destructive: 0 62.8% 30.6%;
+ --destructive-foreground: 0 0% 98%;
+ --border: 0 0% 14.9%;
+ --input: 0 0% 14.9%;
+ --ring: 0 0% 83.1%;
+ --chart-1: 220 70% 50%;
+ --chart-2: 160 60% 45%;
+ --chart-3: 30 80% 55%;
+ --chart-4: 280 65% 60%;
+ --chart-5: 340 75% 55%;
+ }
+}
+
+@layer base {
+ * {
+ @apply border-border;
+ }
+ body {
+ @apply bg-background text-foreground;
+ }
+}
diff --git a/src/index.tsx b/src/index.tsx
deleted file mode 100644
index 4c9931e..0000000
--- a/src/index.tsx
+++ /dev/null
@@ -1,19 +0,0 @@
-import React from 'react';
-import ReactDOM from 'react-dom';
-
-import App from './App';
-import reportWebVitals from './reportWebVitals';
-
-import './index.css';
-
-ReactDOM.render(
-
- ,
- document.getElementById('root'),
-);
-
-// If you want to start measuring performance in your app, pass a function
-// to log results (for example: reportWebVitals(console.log))
-// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
-reportWebVitals();
diff --git a/src/lib/escape-member-name.test.ts b/src/lib/escape-member-name.test.ts
new file mode 100644
index 0000000..71b17aa
--- /dev/null
+++ b/src/lib/escape-member-name.test.ts
@@ -0,0 +1,44 @@
+import { expect, test } from "vitest";
+import { escapeMemberName } from "./escape-member-name";
+
+test("member name containing only alphabets should not be escaped", () => {
+ expect(escapeMemberName("abc")).toBe("abc");
+});
+
+test("member name containing only numbers should not be escaped", () => {
+ expect(escapeMemberName("123")).toBe("123");
+});
+
+test("single quote should be escaped", () => {
+ expect(escapeMemberName("a'b")).toBe("a\\'b");
+});
+
+test("single quote should be escaped", () => {
+ expect(escapeMemberName("a'b")).toBe("a\\'b");
+});
+
+test("double quote should not be escaped", () => {
+ expect(escapeMemberName('a"b')).toBe('a"b');
+});
+
+test("commonly used control characters should be escaped", () => {
+ expect(escapeMemberName("a\b\f\n\r\tb")).toBe("a\\b\\f\\n\\r\\tb");
+});
+
+test("backslash should be escaped", () => {
+ expect(escapeMemberName("a\\b")).toBe("a\\\\b");
+});
+
+test("control characters should be escaped", () => {
+ expect(escapeMemberName("a\u0000b")).toBe("a\\u0000b");
+ expect(escapeMemberName("a\u000bb")).toBe("a\\u000bb");
+ expect(escapeMemberName("a\u001fb")).toBe("a\\u001fb");
+});
+
+test("backslash should be escaped", () => {
+ expect(escapeMemberName("a\\b")).toBe("a\\\\b");
+});
+
+test("surrogate pair charctors should not be escaped", () => {
+ expect(escapeMemberName("a🤔b")).toBe("a🤔b");
+});
diff --git a/src/lib/escape-member-name.ts b/src/lib/escape-member-name.ts
new file mode 100644
index 0000000..3054972
--- /dev/null
+++ b/src/lib/escape-member-name.ts
@@ -0,0 +1,29 @@
+/**
+ * Escape a member name for nomalized path
+ * See: https://www.rfc-editor.org/rfc/rfc9535.html#section-2.7
+ * @param name
+ * @returns
+ */
+export const escapeMemberName = (name: string): string => {
+ // eslint-disable-next-line no-control-regex
+ return name.replace(/['\\\b\f\n\r\t\u0000-\u001F]/g, (char) => {
+ switch (char) {
+ case "'":
+ return "\\'";
+ case "\\":
+ return "\\\\";
+ case "\b":
+ return "\\b";
+ case "\f":
+ return "\\f";
+ case "\n":
+ return "\\n";
+ case "\r":
+ return "\\r";
+ case "\t":
+ return "\\t";
+ default:
+ return `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`;
+ }
+ });
+};
diff --git a/src/lib/json-parser/config.cjs b/src/lib/json-parser/config.cjs
new file mode 100644
index 0000000..649c8b0
--- /dev/null
+++ b/src/lib/json-parser/config.cjs
@@ -0,0 +1,5 @@
+module.exports = {
+ format: "es",
+ input: "src/lib/JSONParser/json.peggy",
+ dts: true,
+};
diff --git a/src/lib/json-parser/json.d.ts b/src/lib/json-parser/json.d.ts
new file mode 100644
index 0000000..3939af8
--- /dev/null
+++ b/src/lib/json-parser/json.d.ts
@@ -0,0 +1,209 @@
+/** Provides information pointing to a location within a source. */
+export interface Location {
+ /** Line in the parsed source (1-based). */
+ readonly line: number;
+ /** Column in the parsed source (1-based). */
+ readonly column: number;
+ /** Offset in the parsed source (0-based). */
+ readonly offset: number;
+}
+
+/**
+ * Anything that can successfully be converted to a string with `String()`
+ * so that it can be used in error messages.
+ *
+ * The GrammarLocation class in Peggy is a good example.
+ */
+export interface GrammarSourceObject {
+ readonly toString: () => string;
+
+ /**
+ * If specified, allows the grammar source to be embedded in a larger file
+ * at some offset.
+ */
+ readonly offset?: undefined | ((loc: Location) => Location);
+}
+
+/**
+ * Most often, you just use a string with the file name.
+ */
+export type GrammarSource = string | GrammarSourceObject;
+
+/** The `start` and `end` position's of an object within the source. */
+export interface LocationRange {
+ /**
+ * A string or object that was supplied to the `parse()` call as the
+ * `grammarSource` option.
+ */
+ readonly source: GrammarSource;
+ /** Position at the beginning of the expression. */
+ readonly start: Location;
+ /** Position after the end of the expression. */
+ readonly end: Location;
+}
+
+/**
+ * Expected a literal string, like `"foo"i`.
+ */
+export interface LiteralExpectation {
+ readonly type: "literal";
+ readonly text: string;
+ readonly ignoreCase: boolean;
+}
+
+/**
+ * Range of characters, like `a-z`
+ */
+export type ClassRange = [
+ start: string,
+ end: string,
+]
+
+export interface ClassParts extends Array {
+}
+
+/**
+ * Expected a class, such as `[^acd-gz]i`
+ */
+export interface ClassExpectation {
+ readonly type: "class";
+ readonly parts: ClassParts;
+ readonly inverted: boolean;
+ readonly ignoreCase: boolean;
+}
+
+/**
+ * Expected any character, with `.`
+ */
+export interface AnyExpectation {
+ readonly type: "any";
+}
+
+/**
+ * Expected the end of input.
+ */
+export interface EndExpectation {
+ readonly type: "end";
+}
+
+/**
+ * Expected some other input. These are specified with a rule's
+ * "human-readable name", or with the `expected(message, location)`
+ * function.
+ */
+export interface OtherExpectation {
+ readonly type: "other";
+ readonly description: string;
+}
+
+export type Expectation =
+ | AnyExpectation
+ | ClassExpectation
+ | EndExpectation
+ | LiteralExpectation
+ | OtherExpectation;
+
+/**
+ * Pass an array of these into `SyntaxError.prototype.format()`
+ */
+export interface SourceText {
+ /**
+ * Identifier of an input that was used as a grammarSource in parse().
+ */
+ readonly source: GrammarSource;
+ /** Source text of the input. */
+ readonly text: string;
+}
+
+export declare class SyntaxError extends Error {
+ /**
+ * Constructs the human-readable message from the machine representation.
+ *
+ * @param expected Array of expected items, generated by the parser
+ * @param found Any text that will appear as found in the input instead of
+ * expected
+ */
+ static buildMessage(expected: Expectation[], found?: string | null | undefined): string;
+ readonly message: string;
+ readonly expected: Expectation[];
+ readonly found: string | null | undefined;
+ readonly location: LocationRange;
+ readonly name: string;
+ constructor(
+ message: string,
+ expected: Expectation[],
+ found: string | null,
+ location: LocationRange,
+ );
+
+ /**
+ * With good sources, generates a feature-rich error message pointing to the
+ * error in the input.
+ * @param sources List of {source, text} objects that map to the input.
+ */
+ format(sources: SourceText[]): string;
+}
+
+/**
+ * Trace execution of the parser.
+ */
+export interface ParserTracer {
+ trace: (event: ParserTracerEvent) => void;
+}
+
+export type ParserTracerEvent
+ = {
+ readonly type: "rule.enter";
+ readonly rule: string;
+ readonly location: LocationRange
+ }
+ | {
+ readonly type: "rule.fail";
+ readonly rule: string;
+ readonly location: LocationRange
+ }
+ | {
+ readonly type: "rule.match";
+ readonly rule: string;
+ readonly location: LocationRange
+ /** Return value from the rule. */
+ readonly result: unknown;
+ };
+
+export type StartRuleNames = "JSON_text";
+export interface ParseOptions {
+ /**
+ * String or object that will be attached to the each `LocationRange` object
+ * created by the parser. For example, this can be path to the parsed file
+ * or even the File object.
+ */
+ readonly grammarSource?: GrammarSource;
+ readonly startRule?: T;
+ readonly tracer?: ParserTracer;
+
+ // Internal use only:
+ readonly peg$library?: boolean;
+ // Internal use only:
+ peg$currPos?: number;
+ // Internal use only:
+ peg$silentFails?: number;
+ // Internal use only:
+ peg$maxFailExpected?: Expectation[];
+ // Extra application-specific properties
+ [key: string]: unknown;
+}
+
+export declare const StartRules: StartRuleNames[];
+export declare const parse: typeof ParseFunction;
+
+// Overload of ParseFunction for each allowedStartRule
+
+declare function ParseFunction>(
+ input: string,
+ options?: Options,
+): any;
+
+declare function ParseFunction>(
+ input: string,
+ options?: Options,
+): any;
diff --git a/src/lib/json-parser/json.js b/src/lib/json-parser/json.js
new file mode 100644
index 0000000..3dfd45a
--- /dev/null
+++ b/src/lib/json-parser/json.js
@@ -0,0 +1,1393 @@
+// @generated by Peggy 4.2.0.
+//
+// https://peggyjs.org/
+
+
+function peg$subclass(child, parent) {
+ function C() { this.constructor = child; }
+ C.prototype = parent.prototype;
+ child.prototype = new C();
+}
+
+function peg$SyntaxError(message, expected, found, location) {
+ var self = Error.call(this, message);
+ // istanbul ignore next Check is a necessary evil to support older environments
+ if (Object.setPrototypeOf) {
+ Object.setPrototypeOf(self, peg$SyntaxError.prototype);
+ }
+ self.expected = expected;
+ self.found = found;
+ self.location = location;
+ self.name = "SyntaxError";
+ return self;
+}
+
+peg$subclass(peg$SyntaxError, Error);
+
+function peg$padEnd(str, targetLength, padString) {
+ padString = padString || " ";
+ if (str.length > targetLength) { return str; }
+ targetLength -= str.length;
+ padString += padString.repeat(targetLength);
+ return str + padString.slice(0, targetLength);
+}
+
+peg$SyntaxError.prototype.format = function(sources) {
+ var str = "Error: " + this.message;
+ if (this.location) {
+ var src = null;
+ var k;
+ for (k = 0; k < sources.length; k++) {
+ if (sources[k].source === this.location.source) {
+ src = sources[k].text.split(/\r\n|\n|\r/g);
+ break;
+ }
+ }
+ var s = this.location.start;
+ var offset_s = (this.location.source && (typeof this.location.source.offset === "function"))
+ ? this.location.source.offset(s)
+ : s;
+ var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column;
+ if (src) {
+ var e = this.location.end;
+ var filler = peg$padEnd("", offset_s.line.toString().length, ' ');
+ var line = src[s.line - 1];
+ var last = s.line === e.line ? e.column : line.length + 1;
+ var hatLen = (last - s.column) || 1;
+ str += "\n --> " + loc + "\n"
+ + filler + " |\n"
+ + offset_s.line + " | " + line + "\n"
+ + filler + " | " + peg$padEnd("", s.column - 1, ' ')
+ + peg$padEnd("", hatLen, "^");
+ } else {
+ str += "\n at " + loc;
+ }
+ }
+ return str;
+};
+
+peg$SyntaxError.buildMessage = function(expected, found) {
+ var DESCRIBE_EXPECTATION_FNS = {
+ literal: function(expectation) {
+ return "\"" + literalEscape(expectation.text) + "\"";
+ },
+
+ class: function(expectation) {
+ var escapedParts = expectation.parts.map(function(part) {
+ return Array.isArray(part)
+ ? classEscape(part[0]) + "-" + classEscape(part[1])
+ : classEscape(part);
+ });
+
+ return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]";
+ },
+
+ any: function() {
+ return "any character";
+ },
+
+ end: function() {
+ return "end of input";
+ },
+
+ other: function(expectation) {
+ return expectation.description;
+ }
+ };
+
+ function hex(ch) {
+ return ch.charCodeAt(0).toString(16).toUpperCase();
+ }
+
+ function literalEscape(s) {
+ return s
+ .replace(/\\/g, "\\\\")
+ .replace(/"/g, "\\\"")
+ .replace(/\0/g, "\\0")
+ .replace(/\t/g, "\\t")
+ .replace(/\n/g, "\\n")
+ .replace(/\r/g, "\\r")
+ .replace(/[\x00-\x0F]/g, function(ch) { return "\\x0" + hex(ch); })
+ .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return "\\x" + hex(ch); });
+ }
+
+ function classEscape(s) {
+ return s
+ .replace(/\\/g, "\\\\")
+ .replace(/\]/g, "\\]")
+ .replace(/\^/g, "\\^")
+ .replace(/-/g, "\\-")
+ .replace(/\0/g, "\\0")
+ .replace(/\t/g, "\\t")
+ .replace(/\n/g, "\\n")
+ .replace(/\r/g, "\\r")
+ .replace(/[\x00-\x0F]/g, function(ch) { return "\\x0" + hex(ch); })
+ .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return "\\x" + hex(ch); });
+ }
+
+ function describeExpectation(expectation) {
+ return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+ }
+
+ function describeExpected(expected) {
+ var descriptions = expected.map(describeExpectation);
+ var i, j;
+
+ descriptions.sort();
+
+ if (descriptions.length > 0) {
+ for (i = 1, j = 1; i < descriptions.length; i++) {
+ if (descriptions[i - 1] !== descriptions[i]) {
+ descriptions[j] = descriptions[i];
+ j++;
+ }
+ }
+ descriptions.length = j;
+ }
+
+ switch (descriptions.length) {
+ case 1:
+ return descriptions[0];
+
+ case 2:
+ return descriptions[0] + " or " + descriptions[1];
+
+ default:
+ return descriptions.slice(0, -1).join(", ")
+ + ", or "
+ + descriptions[descriptions.length - 1];
+ }
+ }
+
+ function describeFound(found) {
+ return found ? "\"" + literalEscape(found) + "\"" : "end of input";
+ }
+
+ return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+};
+
+function peg$parse(input, options) {
+ options = options !== undefined ? options : {};
+
+ var peg$FAILED = {};
+ var peg$source = options.grammarSource;
+
+ var peg$startRuleFunctions = { JSON_text: peg$parseJSON_text };
+ var peg$startRuleFunction = peg$parseJSON_text;
+
+ var peg$c0 = "[";
+ var peg$c1 = "{";
+ var peg$c2 = "]";
+ var peg$c3 = "}";
+ var peg$c4 = ":";
+ var peg$c5 = ",";
+ var peg$c6 = "false";
+ var peg$c7 = "null";
+ var peg$c8 = "true";
+ var peg$c9 = ".";
+ var peg$c10 = "-";
+ var peg$c11 = "+";
+ var peg$c12 = "0";
+ var peg$c13 = "b";
+ var peg$c14 = "f";
+ var peg$c15 = "n";
+ var peg$c16 = "r";
+ var peg$c17 = "t";
+ var peg$c18 = "u";
+ var peg$c19 = "\\";
+ var peg$c20 = "\"";
+
+ var peg$r0 = /^[ \t\n\r]/;
+ var peg$r1 = /^[1-9]/;
+ var peg$r2 = /^[eE]/;
+ var peg$r3 = /^[+\-]/;
+ var peg$r4 = /^["\/\\]/;
+ var peg$r5 = /^[^\0-\x1F"\\]/;
+ var peg$r6 = /^[0-9]/;
+ var peg$r7 = /^[0-9a-f]/i;
+
+ var peg$e0 = peg$literalExpectation("[", false);
+ var peg$e1 = peg$literalExpectation("{", false);
+ var peg$e2 = peg$literalExpectation("]", false);
+ var peg$e3 = peg$literalExpectation("}", false);
+ var peg$e4 = peg$literalExpectation(":", false);
+ var peg$e5 = peg$literalExpectation(",", false);
+ var peg$e6 = peg$otherExpectation("whitespace");
+ var peg$e7 = peg$classExpectation([" ", "\t", "\n", "\r"], false, false);
+ var peg$e8 = peg$literalExpectation("false", false);
+ var peg$e9 = peg$literalExpectation("null", false);
+ var peg$e10 = peg$literalExpectation("true", false);
+ var peg$e11 = peg$otherExpectation("number");
+ var peg$e12 = peg$literalExpectation(".", false);
+ var peg$e13 = peg$classExpectation([["1", "9"]], false, false);
+ var peg$e14 = peg$classExpectation(["e", "E"], false, false);
+ var peg$e15 = peg$classExpectation(["+", "-"], false, false);
+ var peg$e16 = peg$literalExpectation("-", false);
+ var peg$e17 = peg$literalExpectation("+", false);
+ var peg$e18 = peg$literalExpectation("0", false);
+ var peg$e19 = peg$otherExpectation("string");
+ var peg$e20 = peg$classExpectation(["\"", "/", "\\"], false, false);
+ var peg$e21 = peg$literalExpectation("b", false);
+ var peg$e22 = peg$literalExpectation("f", false);
+ var peg$e23 = peg$literalExpectation("n", false);
+ var peg$e24 = peg$literalExpectation("r", false);
+ var peg$e25 = peg$literalExpectation("t", false);
+ var peg$e26 = peg$literalExpectation("u", false);
+ var peg$e27 = peg$literalExpectation("\\", false);
+ var peg$e28 = peg$literalExpectation("\"", false);
+ var peg$e29 = peg$classExpectation([["\0", "\x1F"], "\"", "\\"], true, false);
+ var peg$e30 = peg$classExpectation([["0", "9"]], false, false);
+ var peg$e31 = peg$classExpectation([["0", "9"], ["a", "f"]], false, true);
+
+ var peg$f0 = function() { return { location: localtion(), type: "primitive", value: false }; };
+ var peg$f1 = function() { return { location: localtion(), type: "primitive", value: null }; };
+ var peg$f2 = function() { return { location: localtion(), type: "primitive", value: true }; };
+ var peg$f3 = function(head, tail) {
+ return [head].concat(tail);;
+ };
+ var peg$f4 = function(members) { return members !== null
+ ? { location: location(), type: "object", children: members }
+ : { location: location(), type: "object", children: [] };
+ };
+ var peg$f5 = function(name, value) {
+ return {
+ type: "member",
+ location: location(),
+ name: name.value,
+ children: [value]
+ };
+ };
+ var peg$f6 = function(head, tail) { return [head].concat(tail); };
+ var peg$f7 = function(values) {
+ return values !== null
+ ? { location: location(), type: "array", children: values }
+ : { location: location(), type: "array", children: [] };
+ };
+ var peg$f8 = function() { return { location: location(), type: "primitive", value: parseFloat(text()) }; };
+ var peg$f9 = function(chars) {
+ return { location: location(), type: "primitive", value: chars.join("") };
+ };
+ var peg$f10 = function() { return "\b"; };
+ var peg$f11 = function() { return "\f"; };
+ var peg$f12 = function() { return "\n"; };
+ var peg$f13 = function() { return "\r"; };
+ var peg$f14 = function() { return "\t"; };
+ var peg$f15 = function(digits) {
+ return String.fromCharCode(parseInt(digits, 16));
+ };
+ var peg$f16 = function(sequence) { return sequence; };
+ var peg$currPos = options.peg$currPos | 0;
+ var peg$savedPos = peg$currPos;
+ var peg$posDetailsCache = [{ line: 1, column: 1 }];
+ var peg$maxFailPos = peg$currPos;
+ var peg$maxFailExpected = options.peg$maxFailExpected || [];
+ var peg$silentFails = options.peg$silentFails | 0;
+
+ var peg$result;
+
+ if (options.startRule) {
+ if (!(options.startRule in peg$startRuleFunctions)) {
+ throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
+ }
+
+ peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+ }
+
+ function text() {
+ return input.substring(peg$savedPos, peg$currPos);
+ }
+
+ function offset() {
+ return peg$savedPos;
+ }
+
+ function range() {
+ return {
+ source: peg$source,
+ start: peg$savedPos,
+ end: peg$currPos
+ };
+ }
+
+ function location() {
+ return peg$computeLocation(peg$savedPos, peg$currPos);
+ }
+
+ function expected(description, location) {
+ location = location !== undefined
+ ? location
+ : peg$computeLocation(peg$savedPos, peg$currPos);
+
+ throw peg$buildStructuredError(
+ [peg$otherExpectation(description)],
+ input.substring(peg$savedPos, peg$currPos),
+ location
+ );
+ }
+
+ function error(message, location) {
+ location = location !== undefined
+ ? location
+ : peg$computeLocation(peg$savedPos, peg$currPos);
+
+ throw peg$buildSimpleError(message, location);
+ }
+
+ function peg$literalExpectation(text, ignoreCase) {
+ return { type: "literal", text: text, ignoreCase: ignoreCase };
+ }
+
+ function peg$classExpectation(parts, inverted, ignoreCase) {
+ return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
+ }
+
+ function peg$anyExpectation() {
+ return { type: "any" };
+ }
+
+ function peg$endExpectation() {
+ return { type: "end" };
+ }
+
+ function peg$otherExpectation(description) {
+ return { type: "other", description: description };
+ }
+
+ function peg$computePosDetails(pos) {
+ var details = peg$posDetailsCache[pos];
+ var p;
+
+ if (details) {
+ return details;
+ } else {
+ if (pos >= peg$posDetailsCache.length) {
+ p = peg$posDetailsCache.length - 1;
+ } else {
+ p = pos;
+ while (!peg$posDetailsCache[--p]) {}
+ }
+
+ details = peg$posDetailsCache[p];
+ details = {
+ line: details.line,
+ column: details.column
+ };
+
+ while (p < pos) {
+ if (input.charCodeAt(p) === 10) {
+ details.line++;
+ details.column = 1;
+ } else {
+ details.column++;
+ }
+
+ p++;
+ }
+
+ peg$posDetailsCache[pos] = details;
+
+ return details;
+ }
+ }
+
+ function peg$computeLocation(startPos, endPos, offset) {
+ var startPosDetails = peg$computePosDetails(startPos);
+ var endPosDetails = peg$computePosDetails(endPos);
+
+ var res = {
+ source: peg$source,
+ start: {
+ offset: startPos,
+ line: startPosDetails.line,
+ column: startPosDetails.column
+ },
+ end: {
+ offset: endPos,
+ line: endPosDetails.line,
+ column: endPosDetails.column
+ }
+ };
+ if (offset && peg$source && (typeof peg$source.offset === "function")) {
+ res.start = peg$source.offset(res.start);
+ res.end = peg$source.offset(res.end);
+ }
+ return res;
+ }
+
+ function peg$fail(expected) {
+ if (peg$currPos < peg$maxFailPos) { return; }
+
+ if (peg$currPos > peg$maxFailPos) {
+ peg$maxFailPos = peg$currPos;
+ peg$maxFailExpected = [];
+ }
+
+ peg$maxFailExpected.push(expected);
+ }
+
+ function peg$buildSimpleError(message, location) {
+ return new peg$SyntaxError(message, null, null, location);
+ }
+
+ function peg$buildStructuredError(expected, found, location) {
+ return new peg$SyntaxError(
+ peg$SyntaxError.buildMessage(expected, found),
+ expected,
+ found,
+ location
+ );
+ }
+
+ function peg$parseJSON_text() {
+ var s0, s1, s2, s3;
+
+ s0 = peg$currPos;
+ s1 = peg$parsews();
+ s2 = peg$parsevalue();
+ if (s2 !== peg$FAILED) {
+ s3 = peg$parsews();
+ s0 = s2;
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parsebegin_array() {
+ var s0, s1, s2, s3;
+
+ s0 = peg$currPos;
+ s1 = peg$parsews();
+ if (input.charCodeAt(peg$currPos) === 91) {
+ s2 = peg$c0;
+ peg$currPos++;
+ } else {
+ s2 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e0); }
+ }
+ if (s2 !== peg$FAILED) {
+ s3 = peg$parsews();
+ s1 = [s1, s2, s3];
+ s0 = s1;
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parsebegin_object() {
+ var s0, s1, s2, s3;
+
+ s0 = peg$currPos;
+ s1 = peg$parsews();
+ if (input.charCodeAt(peg$currPos) === 123) {
+ s2 = peg$c1;
+ peg$currPos++;
+ } else {
+ s2 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e1); }
+ }
+ if (s2 !== peg$FAILED) {
+ s3 = peg$parsews();
+ s1 = [s1, s2, s3];
+ s0 = s1;
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parseend_array() {
+ var s0, s1, s2, s3;
+
+ s0 = peg$currPos;
+ s1 = peg$parsews();
+ if (input.charCodeAt(peg$currPos) === 93) {
+ s2 = peg$c2;
+ peg$currPos++;
+ } else {
+ s2 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e2); }
+ }
+ if (s2 !== peg$FAILED) {
+ s3 = peg$parsews();
+ s1 = [s1, s2, s3];
+ s0 = s1;
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parseend_object() {
+ var s0, s1, s2, s3;
+
+ s0 = peg$currPos;
+ s1 = peg$parsews();
+ if (input.charCodeAt(peg$currPos) === 125) {
+ s2 = peg$c3;
+ peg$currPos++;
+ } else {
+ s2 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e3); }
+ }
+ if (s2 !== peg$FAILED) {
+ s3 = peg$parsews();
+ s1 = [s1, s2, s3];
+ s0 = s1;
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parsename_separator() {
+ var s0, s1, s2, s3;
+
+ s0 = peg$currPos;
+ s1 = peg$parsews();
+ if (input.charCodeAt(peg$currPos) === 58) {
+ s2 = peg$c4;
+ peg$currPos++;
+ } else {
+ s2 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e4); }
+ }
+ if (s2 !== peg$FAILED) {
+ s3 = peg$parsews();
+ s1 = [s1, s2, s3];
+ s0 = s1;
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parsevalue_separator() {
+ var s0, s1, s2, s3;
+
+ s0 = peg$currPos;
+ s1 = peg$parsews();
+ if (input.charCodeAt(peg$currPos) === 44) {
+ s2 = peg$c5;
+ peg$currPos++;
+ } else {
+ s2 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e5); }
+ }
+ if (s2 !== peg$FAILED) {
+ s3 = peg$parsews();
+ s1 = [s1, s2, s3];
+ s0 = s1;
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parsews() {
+ var s0, s1;
+
+ peg$silentFails++;
+ s0 = [];
+ s1 = input.charAt(peg$currPos);
+ if (peg$r0.test(s1)) {
+ peg$currPos++;
+ } else {
+ s1 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e7); }
+ }
+ while (s1 !== peg$FAILED) {
+ s0.push(s1);
+ s1 = input.charAt(peg$currPos);
+ if (peg$r0.test(s1)) {
+ peg$currPos++;
+ } else {
+ s1 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e7); }
+ }
+ }
+ peg$silentFails--;
+ s1 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e6); }
+
+ return s0;
+ }
+
+ function peg$parsevalue() {
+ var s0;
+
+ s0 = peg$parsefalse();
+ if (s0 === peg$FAILED) {
+ s0 = peg$parsenull();
+ if (s0 === peg$FAILED) {
+ s0 = peg$parsetrue();
+ if (s0 === peg$FAILED) {
+ s0 = peg$parseobject();
+ if (s0 === peg$FAILED) {
+ s0 = peg$parsearray();
+ if (s0 === peg$FAILED) {
+ s0 = peg$parsenumber();
+ if (s0 === peg$FAILED) {
+ s0 = peg$parsestring();
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return s0;
+ }
+
+ function peg$parsefalse() {
+ var s0, s1;
+
+ s0 = peg$currPos;
+ if (input.substr(peg$currPos, 5) === peg$c6) {
+ s1 = peg$c6;
+ peg$currPos += 5;
+ } else {
+ s1 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e8); }
+ }
+ if (s1 !== peg$FAILED) {
+ peg$savedPos = s0;
+ s1 = peg$f0();
+ }
+ s0 = s1;
+
+ return s0;
+ }
+
+ function peg$parsenull() {
+ var s0, s1;
+
+ s0 = peg$currPos;
+ if (input.substr(peg$currPos, 4) === peg$c7) {
+ s1 = peg$c7;
+ peg$currPos += 4;
+ } else {
+ s1 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e9); }
+ }
+ if (s1 !== peg$FAILED) {
+ peg$savedPos = s0;
+ s1 = peg$f1();
+ }
+ s0 = s1;
+
+ return s0;
+ }
+
+ function peg$parsetrue() {
+ var s0, s1;
+
+ s0 = peg$currPos;
+ if (input.substr(peg$currPos, 4) === peg$c8) {
+ s1 = peg$c8;
+ peg$currPos += 4;
+ } else {
+ s1 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e10); }
+ }
+ if (s1 !== peg$FAILED) {
+ peg$savedPos = s0;
+ s1 = peg$f2();
+ }
+ s0 = s1;
+
+ return s0;
+ }
+
+ function peg$parseobject() {
+ var s0, s1, s2, s3, s4, s5, s6, s7;
+
+ s0 = peg$currPos;
+ s1 = peg$parsebegin_object();
+ if (s1 !== peg$FAILED) {
+ s2 = peg$currPos;
+ s3 = peg$parsemember();
+ if (s3 !== peg$FAILED) {
+ s4 = [];
+ s5 = peg$currPos;
+ s6 = peg$parsevalue_separator();
+ if (s6 !== peg$FAILED) {
+ s7 = peg$parsemember();
+ if (s7 !== peg$FAILED) {
+ s5 = s7;
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ while (s5 !== peg$FAILED) {
+ s4.push(s5);
+ s5 = peg$currPos;
+ s6 = peg$parsevalue_separator();
+ if (s6 !== peg$FAILED) {
+ s7 = peg$parsemember();
+ if (s7 !== peg$FAILED) {
+ s5 = s7;
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ }
+ peg$savedPos = s2;
+ s2 = peg$f3(s3, s4);
+ } else {
+ peg$currPos = s2;
+ s2 = peg$FAILED;
+ }
+ if (s2 === peg$FAILED) {
+ s2 = null;
+ }
+ s3 = peg$parseend_object();
+ if (s3 !== peg$FAILED) {
+ peg$savedPos = s0;
+ s0 = peg$f4(s2);
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parsemember() {
+ var s0, s1, s2, s3;
+
+ s0 = peg$currPos;
+ s1 = peg$parsestring();
+ if (s1 !== peg$FAILED) {
+ s2 = peg$parsename_separator();
+ if (s2 !== peg$FAILED) {
+ s3 = peg$parsevalue();
+ if (s3 !== peg$FAILED) {
+ peg$savedPos = s0;
+ s0 = peg$f5(s1, s3);
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parsearray() {
+ var s0, s1, s2, s3, s4, s5, s6, s7;
+
+ s0 = peg$currPos;
+ s1 = peg$parsebegin_array();
+ if (s1 !== peg$FAILED) {
+ s2 = peg$currPos;
+ s3 = peg$parsevalue();
+ if (s3 !== peg$FAILED) {
+ s4 = [];
+ s5 = peg$currPos;
+ s6 = peg$parsevalue_separator();
+ if (s6 !== peg$FAILED) {
+ s7 = peg$parsevalue();
+ if (s7 !== peg$FAILED) {
+ s5 = s7;
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ while (s5 !== peg$FAILED) {
+ s4.push(s5);
+ s5 = peg$currPos;
+ s6 = peg$parsevalue_separator();
+ if (s6 !== peg$FAILED) {
+ s7 = peg$parsevalue();
+ if (s7 !== peg$FAILED) {
+ s5 = s7;
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ }
+ peg$savedPos = s2;
+ s2 = peg$f6(s3, s4);
+ } else {
+ peg$currPos = s2;
+ s2 = peg$FAILED;
+ }
+ if (s2 === peg$FAILED) {
+ s2 = null;
+ }
+ s3 = peg$parseend_array();
+ if (s3 !== peg$FAILED) {
+ peg$savedPos = s0;
+ s0 = peg$f7(s2);
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parsenumber() {
+ var s0, s1, s2, s3, s4;
+
+ peg$silentFails++;
+ s0 = peg$currPos;
+ s1 = peg$parseminus();
+ if (s1 === peg$FAILED) {
+ s1 = null;
+ }
+ s2 = peg$parseint();
+ if (s2 !== peg$FAILED) {
+ s3 = peg$parsefrac();
+ if (s3 === peg$FAILED) {
+ s3 = null;
+ }
+ s4 = peg$parseexp();
+ if (s4 === peg$FAILED) {
+ s4 = null;
+ }
+ peg$savedPos = s0;
+ s0 = peg$f8();
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ peg$silentFails--;
+ if (s0 === peg$FAILED) {
+ s1 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e11); }
+ }
+
+ return s0;
+ }
+
+ function peg$parsedecimal_point() {
+ var s0;
+
+ if (input.charCodeAt(peg$currPos) === 46) {
+ s0 = peg$c9;
+ peg$currPos++;
+ } else {
+ s0 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e12); }
+ }
+
+ return s0;
+ }
+
+ function peg$parsedigit1_9() {
+ var s0;
+
+ s0 = input.charAt(peg$currPos);
+ if (peg$r1.test(s0)) {
+ peg$currPos++;
+ } else {
+ s0 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e13); }
+ }
+
+ return s0;
+ }
+
+ function peg$parsee() {
+ var s0;
+
+ s0 = input.charAt(peg$currPos);
+ if (peg$r2.test(s0)) {
+ peg$currPos++;
+ } else {
+ s0 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e14); }
+ }
+
+ return s0;
+ }
+
+ function peg$parseexp() {
+ var s0, s1, s2, s3, s4;
+
+ s0 = peg$currPos;
+ s1 = peg$parsee();
+ if (s1 !== peg$FAILED) {
+ s2 = input.charAt(peg$currPos);
+ if (peg$r3.test(s2)) {
+ peg$currPos++;
+ } else {
+ s2 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e15); }
+ }
+ if (s2 === peg$FAILED) {
+ s2 = null;
+ }
+ s3 = [];
+ s4 = peg$parseDIGIT();
+ if (s4 !== peg$FAILED) {
+ while (s4 !== peg$FAILED) {
+ s3.push(s4);
+ s4 = peg$parseDIGIT();
+ }
+ } else {
+ s3 = peg$FAILED;
+ }
+ if (s3 !== peg$FAILED) {
+ s1 = [s1, s2, s3];
+ s0 = s1;
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parsefrac() {
+ var s0, s1, s2, s3;
+
+ s0 = peg$currPos;
+ s1 = peg$parsedecimal_point();
+ if (s1 !== peg$FAILED) {
+ s2 = [];
+ s3 = peg$parseDIGIT();
+ if (s3 !== peg$FAILED) {
+ while (s3 !== peg$FAILED) {
+ s2.push(s3);
+ s3 = peg$parseDIGIT();
+ }
+ } else {
+ s2 = peg$FAILED;
+ }
+ if (s2 !== peg$FAILED) {
+ s1 = [s1, s2];
+ s0 = s1;
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+
+ return s0;
+ }
+
+ function peg$parseint() {
+ var s0, s1, s2, s3;
+
+ s0 = peg$parsezero();
+ if (s0 === peg$FAILED) {
+ s0 = peg$currPos;
+ s1 = peg$parsedigit1_9();
+ if (s1 !== peg$FAILED) {
+ s2 = [];
+ s3 = peg$parseDIGIT();
+ while (s3 !== peg$FAILED) {
+ s2.push(s3);
+ s3 = peg$parseDIGIT();
+ }
+ s1 = [s1, s2];
+ s0 = s1;
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ }
+
+ return s0;
+ }
+
+ function peg$parseminus() {
+ var s0;
+
+ if (input.charCodeAt(peg$currPos) === 45) {
+ s0 = peg$c10;
+ peg$currPos++;
+ } else {
+ s0 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e16); }
+ }
+
+ return s0;
+ }
+
+ function peg$parseplus() {
+ var s0;
+
+ if (input.charCodeAt(peg$currPos) === 43) {
+ s0 = peg$c11;
+ peg$currPos++;
+ } else {
+ s0 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e17); }
+ }
+
+ return s0;
+ }
+
+ function peg$parsezero() {
+ var s0;
+
+ if (input.charCodeAt(peg$currPos) === 48) {
+ s0 = peg$c12;
+ peg$currPos++;
+ } else {
+ s0 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e18); }
+ }
+
+ return s0;
+ }
+
+ function peg$parsestring() {
+ var s0, s1, s2, s3;
+
+ peg$silentFails++;
+ s0 = peg$currPos;
+ s1 = peg$parsequotation_mark();
+ if (s1 !== peg$FAILED) {
+ s2 = [];
+ s3 = peg$parsechar();
+ while (s3 !== peg$FAILED) {
+ s2.push(s3);
+ s3 = peg$parsechar();
+ }
+ s3 = peg$parsequotation_mark();
+ if (s3 !== peg$FAILED) {
+ peg$savedPos = s0;
+ s0 = peg$f9(s2);
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ peg$silentFails--;
+ if (s0 === peg$FAILED) {
+ s1 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e19); }
+ }
+
+ return s0;
+ }
+
+ function peg$parsechar() {
+ var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
+
+ s0 = peg$parseunescaped();
+ if (s0 === peg$FAILED) {
+ s0 = peg$currPos;
+ s1 = peg$parseescape();
+ if (s1 !== peg$FAILED) {
+ s2 = input.charAt(peg$currPos);
+ if (peg$r4.test(s2)) {
+ peg$currPos++;
+ } else {
+ s2 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e20); }
+ }
+ if (s2 === peg$FAILED) {
+ s2 = peg$currPos;
+ if (input.charCodeAt(peg$currPos) === 98) {
+ s3 = peg$c13;
+ peg$currPos++;
+ } else {
+ s3 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e21); }
+ }
+ if (s3 !== peg$FAILED) {
+ peg$savedPos = s2;
+ s3 = peg$f10();
+ }
+ s2 = s3;
+ if (s2 === peg$FAILED) {
+ s2 = peg$currPos;
+ if (input.charCodeAt(peg$currPos) === 102) {
+ s3 = peg$c14;
+ peg$currPos++;
+ } else {
+ s3 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e22); }
+ }
+ if (s3 !== peg$FAILED) {
+ peg$savedPos = s2;
+ s3 = peg$f11();
+ }
+ s2 = s3;
+ if (s2 === peg$FAILED) {
+ s2 = peg$currPos;
+ if (input.charCodeAt(peg$currPos) === 110) {
+ s3 = peg$c15;
+ peg$currPos++;
+ } else {
+ s3 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e23); }
+ }
+ if (s3 !== peg$FAILED) {
+ peg$savedPos = s2;
+ s3 = peg$f12();
+ }
+ s2 = s3;
+ if (s2 === peg$FAILED) {
+ s2 = peg$currPos;
+ if (input.charCodeAt(peg$currPos) === 114) {
+ s3 = peg$c16;
+ peg$currPos++;
+ } else {
+ s3 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e24); }
+ }
+ if (s3 !== peg$FAILED) {
+ peg$savedPos = s2;
+ s3 = peg$f13();
+ }
+ s2 = s3;
+ if (s2 === peg$FAILED) {
+ s2 = peg$currPos;
+ if (input.charCodeAt(peg$currPos) === 116) {
+ s3 = peg$c17;
+ peg$currPos++;
+ } else {
+ s3 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e25); }
+ }
+ if (s3 !== peg$FAILED) {
+ peg$savedPos = s2;
+ s3 = peg$f14();
+ }
+ s2 = s3;
+ if (s2 === peg$FAILED) {
+ s2 = peg$currPos;
+ if (input.charCodeAt(peg$currPos) === 117) {
+ s3 = peg$c18;
+ peg$currPos++;
+ } else {
+ s3 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e26); }
+ }
+ if (s3 !== peg$FAILED) {
+ s4 = peg$currPos;
+ s5 = peg$currPos;
+ s6 = peg$parseHEXDIG();
+ if (s6 !== peg$FAILED) {
+ s7 = peg$parseHEXDIG();
+ if (s7 !== peg$FAILED) {
+ s8 = peg$parseHEXDIG();
+ if (s8 !== peg$FAILED) {
+ s9 = peg$parseHEXDIG();
+ if (s9 !== peg$FAILED) {
+ s6 = [s6, s7, s8, s9];
+ s5 = s6;
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s5;
+ s5 = peg$FAILED;
+ }
+ if (s5 !== peg$FAILED) {
+ s4 = input.substring(s4, peg$currPos);
+ } else {
+ s4 = s5;
+ }
+ if (s4 !== peg$FAILED) {
+ peg$savedPos = s2;
+ s2 = peg$f15(s4);
+ } else {
+ peg$currPos = s2;
+ s2 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s2;
+ s2 = peg$FAILED;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (s2 !== peg$FAILED) {
+ peg$savedPos = s0;
+ s0 = peg$f16(s2);
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ } else {
+ peg$currPos = s0;
+ s0 = peg$FAILED;
+ }
+ }
+
+ return s0;
+ }
+
+ function peg$parseescape() {
+ var s0;
+
+ if (input.charCodeAt(peg$currPos) === 92) {
+ s0 = peg$c19;
+ peg$currPos++;
+ } else {
+ s0 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e27); }
+ }
+
+ return s0;
+ }
+
+ function peg$parsequotation_mark() {
+ var s0;
+
+ if (input.charCodeAt(peg$currPos) === 34) {
+ s0 = peg$c20;
+ peg$currPos++;
+ } else {
+ s0 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e28); }
+ }
+
+ return s0;
+ }
+
+ function peg$parseunescaped() {
+ var s0;
+
+ s0 = input.charAt(peg$currPos);
+ if (peg$r5.test(s0)) {
+ peg$currPos++;
+ } else {
+ s0 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e29); }
+ }
+
+ return s0;
+ }
+
+ function peg$parseDIGIT() {
+ var s0;
+
+ s0 = input.charAt(peg$currPos);
+ if (peg$r6.test(s0)) {
+ peg$currPos++;
+ } else {
+ s0 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e30); }
+ }
+
+ return s0;
+ }
+
+ function peg$parseHEXDIG() {
+ var s0;
+
+ s0 = input.charAt(peg$currPos);
+ if (peg$r7.test(s0)) {
+ peg$currPos++;
+ } else {
+ s0 = peg$FAILED;
+ if (peg$silentFails === 0) { peg$fail(peg$e31); }
+ }
+
+ return s0;
+ }
+
+ peg$result = peg$startRuleFunction();
+
+ if (options.peg$library) {
+ return /** @type {any} */ ({
+ peg$result,
+ peg$currPos,
+ peg$FAILED,
+ peg$maxFailExpected,
+ peg$maxFailPos
+ });
+ }
+ if (peg$result !== peg$FAILED && peg$currPos === input.length) {
+ return peg$result;
+ } else {
+ if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+ peg$fail(peg$endExpectation());
+ }
+
+ throw peg$buildStructuredError(
+ peg$maxFailExpected,
+ peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
+ peg$maxFailPos < input.length
+ ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
+ : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
+ );
+ }
+}
+
+const peg$allowedStartRules = [
+ "JSON_text"
+];
+
+export {
+ peg$allowedStartRules as StartRules,
+ peg$SyntaxError as SyntaxError,
+ peg$parse as parse
+};
diff --git a/src/lib/json-parser/json.peggy b/src/lib/json-parser/json.peggy
new file mode 100644
index 0000000..19ed3e6
--- /dev/null
+++ b/src/lib/json-parser/json.peggy
@@ -0,0 +1,158 @@
+// JSON Grammar
+// ============
+//
+// Based on the grammar from RFC 7159 [1].
+//
+// Note that JSON is also specified in ECMA-262 [2], ECMA-404 [3], and on the
+// JSON website [4] (somewhat informally). The RFC seems the most authoritative
+// source, which is confirmed e.g. by [5].
+//
+// [1] http://tools.ietf.org/html/rfc7159
+// [2] http://www.ecma-international.org/publications/standards/Ecma-262.htm
+// [3] http://www.ecma-international.org/publications/standards/Ecma-404.htm
+// [4] http://json.org/
+// [5] https://www.tbray.org/ongoing/When/201x/2014/03/05/RFC7159-JSON
+
+// ----- 2. JSON Grammar -----
+
+JSON_text
+ = ws @value ws
+
+begin_array = ws "[" ws
+begin_object = ws "{" ws
+end_array = ws "]" ws
+end_object = ws "}" ws
+name_separator = ws ":" ws
+value_separator = ws "," ws
+
+ws "whitespace" = [ \t\n\r]*
+
+// ----- 3. Values -----
+
+value
+ = false
+ / null
+ / true
+ / object
+ / array
+ / number
+ / string
+
+false = "false" { return { location: localtion(), type: "primitive", value: false }; }
+null = "null" { return { location: localtion(), type: "primitive", value: null }; }
+true = "true" { return { location: localtion(), type: "primitive", value: true }; }
+
+// ----- 4. Objects -----
+
+object
+ = begin_object
+ members:(
+ head:member
+ tail:(value_separator @member)*
+ {
+ return [head].concat(tail);;
+ }
+ )?
+ end_object
+ { return members !== null
+ ? { location: location(), type: "object", children: members }
+ : { location: location(), type: "object", children: [] };
+ }
+
+member
+ = name:string name_separator value:value {
+ return {
+ type: "member",
+ location: location(),
+ name: name.value,
+ children: [value]
+ };
+ }
+
+// ----- 5. Arrays -----
+
+array
+ = begin_array
+ values:(
+ head:value
+ tail:(value_separator @value)*
+ { return [head].concat(tail); }
+ )?
+ end_array
+ {
+ return values !== null
+ ? { location: location(), type: "array", children: values }
+ : { location: location(), type: "array", children: [] };
+ }
+
+// ----- 6. Numbers -----
+
+number "number"
+ = minus? int frac? exp? { return { location: location(), type: "primitive", value: parseFloat(text()) }; }
+
+decimal_point
+ = "."
+
+digit1_9
+ = [1-9]
+
+e
+ = [eE]
+
+exp
+ = e (minus / plus)? DIGIT+
+
+frac
+ = decimal_point DIGIT+
+
+int
+ = zero / (digit1_9 DIGIT*)
+
+minus
+ = "-"
+
+plus
+ = "+"
+
+zero
+ = "0"
+
+// ----- 7. Strings -----
+
+string "string"
+ = quotation_mark chars:char* quotation_mark {
+ return { location: location(), type: "primitive", value: chars.join("") };
+ }
+
+char
+ = unescaped
+ / escape
+ sequence:(
+ '"'
+ / "\\"
+ / "/"
+ / "b" { return "\b"; }
+ / "f" { return "\f"; }
+ / "n" { return "\n"; }
+ / "r" { return "\r"; }
+ / "t" { return "\t"; }
+ / "u" digits:$(HEXDIG HEXDIG HEXDIG HEXDIG) {
+ return String.fromCharCode(parseInt(digits, 16));
+ }
+ )
+ { return sequence; }
+
+escape
+ = "\\"
+
+quotation_mark
+ = '"'
+
+unescaped
+ = [^\0-\x1F\x22\x5C]
+
+// ----- Core ABNF Rules -----
+
+// See RFC 4234, Appendix B (http://tools.ietf.org/html/rfc4234).
+DIGIT = [0-9]
+HEXDIG = [0-9a-f]i
diff --git a/src/lib/jsonpath.ts b/src/lib/jsonpath.ts
new file mode 100644
index 0000000..005550b
--- /dev/null
+++ b/src/lib/jsonpath.ts
@@ -0,0 +1,22 @@
+import { Engine } from "@/types/engine";
+import { JSONPath } from "jsonpath-plus";
+import { JSONValue } from "@/types/json";
+import { JSONPathJS } from "jsonpath-js";
+
+export const evalJsonPath = (
+ engine: Engine,
+ document: JSONValue,
+ query: string
+) => {
+ switch (engine) {
+ case "rfc9535":
+ return new JSONPathJS(query).find(document);
+ case "jsonpath-plus":
+ return JSONPath({
+ json: document,
+ path: query,
+ });
+ default:
+ engine satisfies never;
+ }
+};
diff --git a/src/lib/normalized-path.ts b/src/lib/normalized-path.ts
new file mode 100644
index 0000000..98a2559
--- /dev/null
+++ b/src/lib/normalized-path.ts
@@ -0,0 +1,100 @@
+import { escapeMemberName } from "./escape-member-name";
+import { parse } from "./json-parser/json";
+
+type Position = {
+ line: number;
+ column: number;
+};
+
+type Location = {
+ start: Position;
+ end: Position;
+};
+
+type BaseNode = {
+ type: "object" | "array" | "member" | "primitive";
+ path: string | undefined;
+ location: Location;
+ children: Node[] | undefined;
+};
+
+type ObjectNode = BaseNode & {
+ type: "object";
+};
+
+type MemberNode = BaseNode & {
+ type: "member";
+ name: string;
+};
+
+type ArrayNode = BaseNode & {
+ type: "array";
+};
+
+type PrimitiveNode = BaseNode & {
+ type: "primitive";
+ children: undefined;
+};
+
+export type Node = ObjectNode | MemberNode | ArrayNode | PrimitiveNode;
+
+const inPosition = (node: Node, position: Position) => {
+ const { start, end } = node.location;
+
+ const withinStart =
+ start.line < position.line ||
+ (start.line === position.line && start.column <= position.column);
+ const withinEnd =
+ end.line > position.line ||
+ (end.line === position.line && end.column >= position.column);
+
+ return withinStart && withinEnd;
+};
+
+const traverseNormalizedPath = (node: Node, path: string): void => {
+ if (node.type === "member") {
+ node.path = `${path}['${escapeMemberName(node.name)}']`;
+ } else {
+ node.path = path;
+ }
+
+ if (node.children) {
+ if (node.type === "object") {
+ for (const child of node.children) {
+ traverseNormalizedPath(child, node.path);
+ }
+ } else if (node.type === "array") {
+ for (let i = 0; i < node.children.length; i++) {
+ traverseNormalizedPath(node.children[i], `${path}[${i}]`);
+ }
+ return;
+ } else if (node.type === "member") {
+ traverseNormalizedPath(node.children[0], node.path);
+ }
+ }
+};
+
+export const generateNormalizedPathNode = (json: string): Node => {
+ const rootNode = parse(json) as Node;
+ traverseNormalizedPath(rootNode, "$");
+ return rootNode;
+};
+
+export const findSmallestNode = (
+ node: Node,
+ position: Position
+): Node | undefined => {
+ if (inPosition(node, position)) {
+ if (node.children) {
+ const children = node.children
+ .map((child) => findSmallestNode(child, position))
+ .filter((child) => child !== undefined);
+ if (children.length > 0) {
+ return children[0];
+ }
+ }
+ return node;
+ } else {
+ return undefined;
+ }
+};
diff --git a/src/lib/utils.ts b/src/lib/utils.ts
new file mode 100644
index 0000000..bd0c391
--- /dev/null
+++ b/src/lib/utils.ts
@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+ return twMerge(clsx(inputs))
+}
diff --git a/src/main.tsx b/src/main.tsx
new file mode 100644
index 0000000..bfabecf
--- /dev/null
+++ b/src/main.tsx
@@ -0,0 +1,10 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import App from "./app";
+import "./index.css";
+
+createRoot(document.getElementById("root")!).render(
+
+
+);
diff --git a/src/react-app-env.d.ts b/src/react-app-env.d.ts
deleted file mode 100644
index 6431bc5..0000000
--- a/src/react-app-env.d.ts
+++ /dev/null
@@ -1 +0,0 @@
-///