@astronautlabs/jsonpath

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results

License

MIT

JSONPath.nodes(obj, pathExpression[, count])

Find elements and their corresponding paths in __INLINE_CODE_31__ matching __INLINE_CODE_32__. Returns an array of node objects where each node has a __INLINE_CODE_33__ containing an array of keys representing the location within __INLINE_CODE_34__, and a __INLINE_CODE_35__ pointing to the matched element. Returns only first __INLINE_CODE_36__ nodes if specified.

JSONPath.value(obj, pathExpression[, newValue])

Returns the value of the first element matching __INLINE_CODE_37__. If __INLINE_CODE_38__ is provided, sets the value of the first matching element and returns the new value.

JSONPath.parent(obj, pathExpression)

Returns the parent of the first matching element.

JSONPath.apply(obj, pathExpression, fn)

Runs the supplied function __INLINE_CODE_39__ on each matching element, and replaces each matching element with the return value from the function. The function accepts the value of the matching element as its only parameter. Returns matching nodes with their updated values.

JSONPath.parse(pathExpression)

Parse the provided JSONPath expression into path components and their associated operations.

JSONPath.stringify(path)

Returns a path expression in string form, given a path. The supplied path may either be a flat array of keys, as returned by __INLINE_CODE_40__ for example, or may alternatively be a fully parsed path expression in the form of an array of path components as returned by __INLINE_CODE_41__.

Differences from Original Implementation

This implementation aims to be compatible with Stefan Goessner's original implementation with a few notable exceptions described below.

Evaluating Script Expressions

Script expressions (i.e, __INLINE_CODE_42__ and __INLINE_CODE_43__) are statically evaluated via static-eval rather than using the underlying script engine directly. That means both that the scope is limited to the instance variable (__INLINE_CODE_44__), and only simple expressions (with no side effects) will be valid. So for example, __INLINE_CODE_45__ will be just fine to match arrays with more than ten elements, but __INLINE_CODE_46__ will not get evaluated since __INLINE_CODE_47__ would yield a __INLINE_CODE_48__. This method is even safer than __INLINE_CODE_49__, since the script engine itself is more limited and entirely distinct from the one running the application code. See more details in the implementation of the evaluator.

Grammar

This project uses a formal BNF grammar to parse JSONPath expressions, an attempt at reverse-engineering the intent of the original implementation, which parses via a series of creative regular expressions. The original regex approach can sometimes be forgiving for better or for worse (e.g., __INLINE_CODE_50__ => __INLINE_CODE_51__), and in other cases, can be just plain wrong (e.g. __INLINE_CODE_52__ => __INLINE_CODE_53__).

Other Minor Differences

As a result of using a real parser and static evaluation, there are some arguable bugs in the original library that have not been carried through here:

• strings in subscripts may now be double-quoted
• final __INLINE_CODE_54__ arguments in slice operators may now be negative
• script expressions may now contain __INLINE_CODE_55__ and __INLINE_CODE_56__ characters not referring to instance variables
• subscripts no longer act as character slices on string elements
• non-ascii non-word characters are no-longer valid in member identifier names; use quoted subscript strings instead (e.g., __INLINE_CODE_57__ instead of __INLINE_CODE_58__)
• unions now yield real unions with no duplicates rather than concatenated results