json_p3 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db1ec71125b99bc877ba9856434a65e3f8e1c11a48b9566443c3b1a8b6860169
-  data.tar.gz: ad176fdda64b4f741e9f86ab48d4c8e3ccd767187fc0fc0fe28a4e6967a071d2
+  metadata.gz: 1c8afa8205821093144f9c2ccbe427e7d726251e48e8cc1480152d0efc8ade7c
+  data.tar.gz: 77639923975a6f89d10cbad38891c59015f06797f084ccaacc78073a5e4161ed
 SHA512:
-  metadata.gz: 3b153a665f534891e1ed1976ca6c180cd1c2427786b9f7b74fcea1953d7337135db669b3541d5eaba7fd2829dbd6c94e6c36236a4a6c6221d1bd5c0ac45f5a04
-  data.tar.gz: 52303daa1cd27c3f3ed7187949f6b9a2cf2c95483e61cd8cf7ced438f5511ad9067f39496b1fe53a85932a3de2be15ebfa2c791fdbc9002aceb0c85395c04839
+  metadata.gz: 178a01fe4d486b0d2787d46edbe93dce36a6fe6b2b30410daaa57f44da385649aad995c1187ac55253d8cdbe2448f86c73bdd56f1142ba066364c24cd9a2dfe9
+  data.tar.gz: 82d38fc46b9d1049135e79d1b3b2aae814ef65285153f5b57242021b7b9b5da5f55f2b5c092cd0e301b6f5ef0b047d59d354bb998c92fe522ecdb2804bc688e9

data/.rubocop.yml

@@ -1,10 +1,10 @@
-require:
+plugins:
   - rubocop-minitest
   - rubocop-rake
   - rubocop-performance
 
 AllCops:
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.3
   NewCops: enable
 
 Style/StringLiterals:
@@ -13,21 +13,40 @@ Style/StringLiterals:
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
 
+Style/ComparableBetween:
+  Enabled: false
+
+Layout/LeadingCommentSpace:
+  Enabled: false
+
 Metrics/AbcSize:
-  Max: 50
+  Enabled: false
 
 Metrics/ClassLength:
-  Max: 500
+  Enabled: false
 
 Metrics/CyclomaticComplexity:
-  Max: 20
+  Enabled: false
 
 Metrics/MethodLength:
-  Max: 50
+  Enabled: false
 
 Metrics/PerceivedComplexity:
-  Max: 20
+  Enabled: false
+
+Metrics/BlockNesting:
+  Max: 4
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
 
 Naming/MethodParameterName:
   AllowedNames:
     - op
+    - ch
+
+Naming/PredicateMethod:
+  Enabled: false

data/.ruby-version

@@ -1 +1 @@
-3.3.6
+4.0.2

data/CHANGELOG.md

@@ -1,3 +1,61 @@
+## [1.0.0] - 2026-04-21
+
+This major release includes breaking changes. No new features have been added.
+
+- Changed the JSONPath tokenizer and parser. The new parser is faster and more JIT friendly.
+- Changed our module and class layout to better separate JSONPath, JSON Pointer and JSON Patch, and to remove "stuttering". For example, previously we had `JSONP3::JSONPathEnvironment` and `JSONP3::JSONPathNode`. Now we have `JSONP3::Path::Environment` and `JSONP3::Path:Node`. This ASCII tree view show our new module and class hierarchy.
+    
+    ```
+    module JSONP3
+    ├── class Error < StandardError
+    │
+    ├── module Path                              # JSONPath (RFC 9535)
+    │   ├── class Environment                    
+    │   ├── class Query    
+    │   ├── class Node
+    │   ├── class NodeList
+    │   ├── class Error < JSONP3::Error
+    │   │    ├── class SyntaxError
+    │   │    ├── class TypeError
+    │   │    ├── class NameError
+    │   │    └── class RecursionError
+    │   ├── def self.find
+    │   ├── def self.find_enum
+    │   ├── def self.compile
+    │   ├── def self.match
+    │   ├── def self.match?
+    │   └── def self.first
+    │
+    ├── class Pointer                            # JSON Pointer (RFC 6901)
+    │   ├── class Error < JSONP3::Error
+    │   │   ├── class IndexError
+    │   │   ├── class SyntaxError
+    │   │   └── class TypeError
+    │   └── def self.resolve
+    │
+    └── class Patch                              # JSON Patch (RFC 6902)
+        ├── class OpAdd                          
+        ├── class OpCopy                          
+        ├── class OpMove                          
+        ├── class OpRemove                       
+        ├── class OpReplace                       
+        ├── class OpTest                       
+        ├── class Error < JSONP3::Error
+        │   └── class TestFailure
+        └── def !self.apply
+    ```
+
+    Note that top-level convenience methods - like `JSONP3.find` and `JSONP3.compile` - are unchanged. Most dependent projects should only need to change error class names.
+
+- Renamed `JSONP3::JSONPath` to `JSONP3::Path::Query`.
+- Renamed `JSONP3::RecursiveDescentSegment` to `JSONP3::Path::DescendantSegment` to better match the spec.
+- Renamed `JSONP3.apply` to `JSONP3.apply!`, `JSONP3::Patch#apply` to `JSONP3::Patch#apply!` and `JSONP3::Patch::Op#apply` to `JSONP3::Patch::Op#apply!`. There is no "safe", non mutating version of `apply!`.
+- Dropped support for Ruby 3.1 and 3.2, they are end of life.
+
+## [0.4.1] - 2025-03-18
+
+- Fixed `JSONPathSyntaxError` claiming "unbalanced parentheses" when the query has balanced brackets.
+
 ## [0.4.0] - 2025-02-10
 
 - Added `JSONP3.find_enum`, `JSONP3::JSONPathEnvironment.find_enum` and `JSONP3::JSONPath.find_enum`. `find_enum` is like `find`, but returns an Enumerable (usually an Enumerator) of `JSONPathNode` instances instead of a `JSONPathNodeList`. `find_enum` can be more efficient for some combinations of query and data, especially for large data and recursive queries.

data/README.md

@@ -16,7 +16,7 @@ We follow <a href="https://datatracker.ietf.org/doc/html/rfc9535">RFC 9535</a> s
     <img alt="Gem Version" src="https://img.shields.io/gem/v/json_p3?style=flat-square">
   </a>
   <a href="https://github.com/jg-rp/ruby-json-p3">
-    <img alt="Static Badge" src="https://img.shields.io/badge/Ruby-3.1%20%7C%203.2%20%7C%203.3%20%7C%203.4-CC342D?style=flat-square">
+    <img alt="Static Badge" src="https://img.shields.io/badge/Ruby-3.3%20%7C%203.4%20%7C%204.0-CC342D?style=flat-square">
   </a>
 </p>
 
@@ -29,6 +29,7 @@ We follow <a href="https://datatracker.ietf.org/doc/html/rfc9535">RFC 9535</a> s
 - [Links](#links)
 - [Related projects](#related-projects)
 - [Quick start](#quick-start)
+- [Class and module layout](#module-layout)
 - [Contributing](#contributing)
 
 ## Install
@@ -36,7 +37,7 @@ We follow <a href="https://datatracker.ietf.org/doc/html/rfc9535">RFC 9535</a> s
 Add `'json_p3'` to your Gemfile:
 
 ```
-gem 'json_p3', '~> 0.2.1'
+gem 'json_p3', '~> 1.0.0'
 ```
 
 Or
@@ -45,6 +46,12 @@ Or
 gem install json_p3
 ```
 
+Or
+
+```
+bundle add json_p3
+```
+
 ### Checksum
 
 JSON P3 is cryptographically signed. To be sure the gem you install hasn't been tampered with, add my public key (if you haven't already) as a trusted certificate:
@@ -70,24 +77,10 @@ require "json"
 data = JSON.parse <<~JSON
   {
     "users": [
-      {
-        "name": "Sue",
-        "score": 100
-      },
-      {
-        "name": "Sally",
-        "score": 84,
-        "admin": false
-      },
-      {
-        "name": "John",
-        "score": 86,
-        "admin": true
-      },
-      {
-        "name": "Jane",
-        "score": 55
-      }
+      { "name": "Sue", "score": 100 },
+      { "name": "Sally", "score": 84, "admin": false },
+      { "name": "John", "score": 86, "admin": true },
+      { "name": "Jane", "score": 55 }
     ],
     "moderator": "John"
   }
@@ -144,15 +137,15 @@ end
 
 ### find
 
-`find(query, value) -> Array<JSONPathNode>`
+`find: (String query, top value) -> Array[JSONP3::Path::Node]`
 
-Apply JSONPath expression _query_ to JSON-like data _value_. An array of JSONPathNode instances is returned, one node for each value matched by _query_. The returned array will be empty if there were no matches.
+Apply query expression _query_ to JSON-like data _value_. An array of `Node` instances is returned, one node for each value matched by _query_.
 
-Each `JSONPathNode` has:
+For each `Node`:
 
-- a `value` attribute, which is the JSON-like value associated with the node.
-- a `location` attribute, which is a nested array of hash/object names and array indices that were required to reach the node's value in the target JSON document.
-- a `path()` method, which returns the normalized path to the node in the target JSON document.
+- `#value` is the JSON-like value associated with the node.
+- `#location` is an array of object keys and array indices used to reach the node's value in the target document.
+- `#path` returns the normalized path to the node in the target JSON document. Normalized paths are computed from `#location` and are not cached between calls.
 
 ```ruby
 require "json_p3"
@@ -161,24 +154,10 @@ require "json"
 data = JSON.parse <<~JSON
   {
     "users": [
-      {
-        "name": "Sue",
-        "score": 100
-      },
-      {
-        "name": "Sally",
-        "score": 84,
-        "admin": false
-      },
-      {
-        "name": "John",
-        "score": 86,
-        "admin": true
-      },
-      {
-        "name": "Jane",
-        "score": 55
-      }
+      { "name": "Sue", "score": 100 },
+      { "name": "Sally", "score": 84, "admin": false },
+      { "name": "John", "score": 86, "admin": true },
+      { "name": "Jane", "score": 55 }
     ],
     "moderator": "John"
   }
@@ -192,11 +171,13 @@ end
 # {"name"=>"John", "score"=>86, "admin"=>true} at $['users'][2]
 ```
 
+The returned array will be empty if there were no matches.
+
 ### find_enum
 
-`find_enum(query, value) -> Enumerable<JSONPathNode>`
+`find_enum: (String query, top value) -> Enumerable[JSONP3::Path::Node]`
 
-`find_enum` is an alternative to `find` which returns an enumerable (usually an enumerator) of `JSONPathNode` instances instead of an array. Depending on the query and the data the query is applied to, `find_enum` can be more efficient than `find`, especially for large data and queries using recursive descent segments.
+`JSONP3.find_enum` is an alternative to `find` which returns an enumerable (usually an enumerator) of `Node` instances instead of an array. Depending on the query and the data the query is applied to, `find_enum` can be more efficient than `find`, especially for large data and queries using descendant segments.
 
 ```ruby
 # ... continued from above
@@ -211,9 +192,9 @@ end
 
 ### compile
 
-`compile(query) -> JSONPath`
+`compile: (String query) -> JSONP3::Path::Query`
 
-Prepare a JSONPath expression for repeated application to different JSON-like data. An instance of `JSONPath` has a `find(data)` method, which behaves similarly to the module-level `find(query, data)` method.
+Prepare a query for repeated application to different JSON-like data. An instance of `Query` has `#find(data)`, which behaves similarly to the module-level `find(query, data)` method.
 
 ```ruby
 require "json_p3"
@@ -222,24 +203,10 @@ require "json"
 data = JSON.parse <<~JSON
   {
     "users": [
-      {
-        "name": "Sue",
-        "score": 100
-      },
-      {
-        "name": "Sally",
-        "score": 84,
-        "admin": false
-      },
-      {
-        "name": "John",
-        "score": 86,
-        "admin": true
-      },
-      {
-        "name": "Jane",
-        "score": 55
-      }
+      { "name": "Sue", "score": 100 },
+      { "name": "Sally", "score": 84, "admin": false },
+      { "name": "John", "score": 86, "admin": true },
+      { "name": "Jane", "score": 55 }
     ],
     "moderator": "John"
   }
@@ -257,48 +224,48 @@ end
 
 ### match / first
 
-`match(query, value) -> JSONPathNode | nil`
+`match: (String query, top value) -> (JSONP3::Path::Node | nil)`
 
-`match` (alias `first`) returns a node for the first available match when applying _query_ to _value_, or `nil` if there were no matches.
+`JSONP3.match` (alias `first`) returns a node for the first available match when applying _query_ to _value_, or `nil` if there were no matches.
 
 ### match?
 
-`match?(query, value) -> bool`
+`match?: (String query, top value) -> bool`
 
-`match?` returns `true` if there was at least one match from applying _query_ to _value_, or `false` otherwise.
+`JSONP3.match?` returns `true` if there was at least one match from applying _query_ to _value_, or `false` otherwise.
 
-### JSONPathEnvironment
+### JSONP3::Path::Environment
 
 The `find`, `find_enum` and `compile` methods described above are convenience methods equivalent to:
 
 ```
-JSONP3::DEFAULT_ENVIRONMENT.find(query, data)
+JSONP3::Path::DEFAULT_ENVIRONMENT.find(query, data)
 ```
 
 ```
-JSONP3::DEFAULT_ENVIRONMENT.find_enum(query, data)
+JSONP3::Path::DEFAULT_ENVIRONMENT.find_enum(query, data)
 ```
 
 and
 
 ```
-JSONP3::DEFAULT_ENVIRONMENT.compile(query)
+JSONP3::Path::DEFAULT_ENVIRONMENT.compile(query)
 ```
 
-You could create your own environment like this:
+You can create your own environment like this:
 
 ```ruby
 require "json_p3"
 
-jsonpath = JSONP3::JSONPathEnvironment.new
+jsonpath = JSONP3::Path::Environment.new
 nodes = jsonpath.find("$.*", { "a" => "b", "c" => "d" })
 pp nodes.map(&:value) # ["b", "d"]
 ```
 
-To configure an environment with custom filter functions or non-standard selectors, inherit from `JSONPathEnvironment` and override some of its constants or the `#setup_function_extensions` method.
+To configure an environment with custom filter functions or non-standard selectors, inherit from `JSONP3::Path::Environment` and override some of its constants or the `#setup_function_extensions` method.
 
 ```ruby
-class MyJSONPathEnvironment < JSONP3::JSONPathEnvironment
+class MyJSONPathEnvironment < JSONP3::Path::Environment
   # The maximum integer allowed when selecting array items by index.
   MAX_INT_INDEX = (2**53) - 1
 
@@ -326,26 +293,33 @@ class MyJSONPathEnvironment < JSONP3::JSONPathEnvironment
   # Override this function to configure JSONPath function extensions.
   # By default, only the standard functions described in RFC 9535 are enabled.
   def setup_function_extensions
-    @function_extensions["length"] = Length.new
-    @function_extensions["count"] = Count.new
-    @function_extensions["value"] = Value.new
-    @function_extensions["match"] = Match.new
-    @function_extensions["search"] = Search.new
+    @function_extensions["length"] = JSONP3::Path::Length.new
+    @function_extensions["count"] = JSONP3::Path::Count.new
+    @function_extensions["value"] = JSONP3::Path::Value.new
+    @function_extensions["match"] = JSONP3::Path::Match.new
+    @function_extensions["search"] = JSONP3::Path::Search.new
   end
 ```
 
-### JSONPathError
+### Errors
 
-`JSONPathError` is the base class for all JSONPath exceptions. The following classes inherit from `JSONPathError` and will only occur when parsing a JSONPath expression, not when applying a path to some data.
+`JSONP3::Error` is the base class for all exceptions raised from this Gem.
 
-- `JSONPathSyntaxError`
-- `JSONPathTypeError`
-- `JSONPathNameError`
+```
+StandardError
+└── JSONP3::Error
+    ├── JSONP3::Path::Error
+    │   └── SyntaxError, TypeError, NameError, RecursionError
+    ├── JSONP3::Pointer::Error
+    │   └── IndexError, SyntaxError, TypeError
+    └── JSONP3::Patch::Error
+        └── TestFailure
+```
 
-`JSONPathError` implements `#detailed_message`. With recent versions of Ruby you should get useful error messages.
+`JSONP3::Path::Error` inherits from `JSONP3::Error` and implements `#detailed_message`. With recent versions of Ruby you should get useful error messages.
 
 ```
-JSONP3::JSONPathSyntaxError: unexpected trailing whitespace
+JSONP3::Path::SyntaxError: unexpected trailing whitespace
   -> '$.foo ' 1:5
   |
 1 | $.foo
@@ -354,9 +328,9 @@ JSONP3::JSONPathSyntaxError: unexpected trailing whitespace
 
 ### resolve
 
-`resolve(pointer, value) -> Object`
+`resolve: (String pointer, top value, ?default: top) -> Object`
 
-Resolve a JSON Pointer (RFC 6901) against some data using `JSONP3.resolve()`.
+Resolve a JSON Pointer (RFC 6901) against some data using `JSONP3.resolve`.
 
 ```ruby
 require "json_p3"
@@ -365,24 +339,10 @@ require "json"
 data = JSON.parse <<~JSON
   {
     "users": [
-      {
-        "name": "Sue",
-        "score": 100
-      },
-      {
-        "name": "Sally",
-        "score": 84,
-        "admin": false
-      },
-      {
-        "name": "John",
-        "score": 86,
-        "admin": true
-      },
-      {
-        "name": "Jane",
-        "score": 55
-      }
+      { "name": "Sue", "score": 100 },
+      { "name": "Sally", "score": 84, "admin": false },
+      { "name": "John", "score": 86, "admin": true },
+      { "name": "Jane", "score": 55 }
     ],
     "moderator": "John"
   }
@@ -392,7 +352,7 @@ puts JSONP3.resolve("/users/1", data)
 # {"name"=>"Sally", "score"=>84, "admin"=>false}
 ```
 
-If a pointer can not be resolved, `JSONP3::JSONPointer::UNDEFINED` is returned instead. You can use your own default value using the `default:` keyword argument.
+If a pointer can not be resolved, `JSONP3::Pointer::UNDEFINED` is returned instead. You can use your own default value using the `default:` keyword argument.
 
 ```ruby
 # continued from above
@@ -400,11 +360,11 @@ If a pointer can not be resolved, `JSONP3::JSONPointer::UNDEFINED` is returned i
 pp JSONP3.resolve("/no/such/thing", data, default: nil) # nil
 ```
 
-### apply
+### apply!
 
-`apply(ops, value) -> Object`
+`apply!: (Array[Patch::Op | Hash[String, untyped]] ops, top value) -> Object`
 
-Apply a JSON Patch ([RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902)) with `JSONP3.apply()`. **Data is modified in place**.
+Apply a JSON Patch ([RFC 6902](https://datatracker.ietf.org/doc/html/rfc6902)) with `JSONP3.apply!`. **Data is modified in place**.
 
 ```ruby
 require "json"
@@ -420,31 +380,73 @@ ops = <<~JSON
 JSON
 
 data = { "some" => { "other" => "thing" } }
-JSONP3.apply(JSON.parse(ops), data)
+JSONP3.apply!(JSON.parse(ops), data)
 pp data
 # {"some"=>{"other"=>"thing", "foo"=>{"bar"=>[1], "else"=>"thing"}}}
 ```
 
-`JSONP3.apply(ops, value)` is a convenience method equivalent to `JSONP3::JSONPatch.new(ops).apply(value)`. Use the `JSONPatch` constructor when you need to apply the same patch to different data.
+`JSONP3.apply!(ops, value)` is a convenience method equivalent to `JSONP3::Patch.new(ops).apply!(value)`. Use the `Patch` constructor when you need to apply the same patch to different data.
 
-As well as passing an array of hashes following RFC 6902 as ops to `JSONPatch`, we offer a builder API to construct JSON Patch documents programmatically.
+As well as passing an array of hashes following RFC 6902 as ops to `Patch`, we offer a builder API to construct JSON Patch documents programmatically.
 
 ```ruby
 require "json_p3"
 
 data = { "some" => { "other" => "thing" } }
 
-patch = JSONP3::JSONPatch.new
-                         .add("/some/foo", { "foo" => [] })
-                         .add("/some/foo", { "bar" => [] })
-                         .copy("/some/other", "/some/foo/else")
-                         .copy("/some/foo/else", "/some/foo/bar/-")
+patch = JSONP3::Patch.new
+                     .add("/some/foo", { "foo" => [] })
+                     .add("/some/foo", { "bar" => [] })
+                     .copy("/some/other", "/some/foo/else")
+                     .copy("/some/foo/else", "/some/foo/bar/-")
 
-patch.apply(data)
+patch.apply!(data)
 pp data
 # {"some"=>{"other"=>"thing", "foo"=>{"bar"=>["thing"], "else"=>"thing"}}}
 ```
 
+## Module layout
+
+```
+module JSONP3
+├── class Error < StandardError
+│
+├── module Path                              # JSONPath (RFC 9535)
+│   ├── class Environment                    
+│   ├── class Query    
+│   ├── class Node
+│   ├── class NodeList
+│   ├── class Error < JSONP3::Error
+│   │    ├── class SyntaxError
+│   │    ├── class TypeError
+│   │    ├── class NameError
+│   │    └── class RecursionError
+│   ├── def self.find
+│   ├── def self.find_enum
+│   ├── def self.compile
+│   ├── def self.match
+│   ├── def self.match?
+│   └── def self.first
+│
+├── class Pointer                            # JSON Pointer (RFC 6901)
+│   ├── class Error < JSONP3::Error
+│   │   ├── class IndexError
+│   │   ├── class SyntaxError
+│   │   └── class TypeError
+│   └── def self.resolve
+│
+└── class Patch                              # JSON Patch (RFC 6902)
+    ├── class OpAdd                          
+    ├── class OpCopy                          
+    ├── class OpMove                          
+    ├── class OpRemove                       
+    ├── class OpReplace                       
+    ├── class OpTest                       
+    ├── class Error < JSONP3::Error
+    │   └── class TestFailure
+    └── def self.!apply
+```
+
 ## Contributing
 
 Your contributions and questions are always welcome. Feel free to ask questions, report bugs or request features on the [issue tracker](https://github.com/jg-rp/ruby-json-p3/issues) or on [Github Discussions](https://github.com/jg-rp/ruby-json-p3/discussions). Pull requests are welcome too.

data/Rakefile

@@ -8,9 +8,9 @@ Minitest::TestTask.create
 require "rubocop/rake_task"
 
 RuboCop::RakeTask.new do |task|
-  task.requires << "rubocop-minitest"
-  task.requires << "rubocop-rake"
-  task.requires << "rubocop-performance"
+  task.plugins << "rubocop-minitest"
+  task.plugins << "rubocop-rake"
+  task.plugins << "rubocop-performance"
 end
 
 require "steep/rake_task"

data/certs/jgrp.pem

@@ -1,27 +1,27 @@
 -----BEGIN CERTIFICATE-----
 MIIEhTCCAu2gAwIBAgIBATANBgkqhkiG9w0BAQsFADBEMRYwFAYDVQQDDA1qYW1l
 c2dyLnByaW9yMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZ
-FgNjb20wHhcNMjQxMDI0MDcxNDAzWhcNMjUxMDI0MDcxNDAzWjBEMRYwFAYDVQQD
+FgNjb20wHhcNMjUxMDI1MDc0ODI4WhcNMjYxMDI1MDc0ODI4WjBEMRYwFAYDVQQD
 DA1qYW1lc2dyLnByaW9yMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJ
-k/IsZAEZFgNjb20wggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDvtEeN
-ZNN153v2ZK+U+Tj7kfRgl52GzmZS7lIG83xvT5/K8xEG5G4Tqiq/aGuDdbnxtd/t
-TQf6CtkixPzwj7WGIwoV28AUHKOJ7UjqRhXIuAn3nmzRLRNK2gVYpvzLTNCyLhIb
-jyZqgvtjR9mmW/Uuq+9LcLN4iFfkW+4dSmcABnkZHWMWGZYMIwoYYpluEUS1KiRZ
-mIALPEGO5JcpVvjpDwaP6GqV0khgnLixz9KlAF+2DCyki21wxtJoxJTuL9H5Ogb+
-k+nDQd9ELFYfbn73UKYGPtoUxkQeNF/ajJAkb/8t0cwUeSgtpSPhWIITWBgdLq11
-svViBlK9UZZC+dWG9x1lueVTG9fXBl69NJ9VA7MaxmHVY133sEySqwZMCrtDYjPX
-wIzLI2U8iSDIsjxTq3F3pbxeD4ee85ZY/xAV9M6fpjmKJERibRZTUPQo9ujHAhVM
-YNbfAHhPRGphT64/ocBjCmonrvA0fB3jP5wduEa5vD3JPOSb7dtCnNzNvDcCAwEA
-AaOBgTB/MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBSswivEK7I4
-DrAJcSgIMhgedOJm5DAiBgNVHREEGzAZgRdqYW1lc2dyLnByaW9yQGdtYWlsLmNv
+k/IsZAEZFgNjb20wggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDYTvQW
+0JzsHenYu4w0iHgJRtU9uK8vkDx1wlMioKlPFkaiMfxqUcTTfg80U/n8n/KKmpdq
+y2rpUqv+VPE2nrfCUncf7ukqs+gF8uehbciMXV4iOzsZmqmtlPUJiGuSyO8REe/O
+ERAyxYV8y5psF+WnW4uQzsWCKTnKbexIc6rf237veuYvYoBpnodJu0mJ0m9tBCFU
+qH3Nk1sHBRIEEwn+nTiIiOMb+QMU5p0NIQkIhJO3el5nEQgIGxMPnie7PnwxPquQ
+1rouuISbLmQy5oKYc9kScwnHdAu2PtnnJFNNuQ37vED375iQgMem/tK8EgMm9/Qr
+Qxd2DQqqehgtEySWntGHTxNLXQouqHIRyqzkbcCatJqC+PBBql1x2N1KqgyvbLM3
+B0dZCdJECr5J8zrluMxYsy7uGMmLz3LZ7PskGaJg4XxXP3j/B/e03/AxDj0neZZu
+xuDLIfMDSNILO1pskMc+Xp0xdnkbS4IjiMDTrhqABuEcdNYH/GpyTiA/I0cCAwEA
+AaOBgTB/MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBR4j7UhnpT9
+mLcAkshwkFtwVpMdejAiBgNVHREEGzAZgRdqYW1lc2dyLnByaW9yQGdtYWlsLmNv
 bTAiBgNVHRIEGzAZgRdqYW1lc2dyLnByaW9yQGdtYWlsLmNvbTANBgkqhkiG9w0B
-AQsFAAOCAYEAdq8q0kDj14XNFMVYdjv1dG6Zaom3hEIkWv7+AsaPVw33puAnffQU
-lb2H1FG0LOGailuzPUadop6w/7oHO2jefj/85V0Tk6Hhk8cQpYQrtQgOHA3nsbmJ
-9JksJ+Y8RbyZP5dDTyZjTG4N3kgwZeNozcLeLj2ONBZRvGAjh8fyHOdLMPVNpM2K
-naRHKdSqWSU728nHDiVvLlGVkRInDmC+gC1msKqSEnQrLiBl27jMbsce9GKi2cb7
-DNjDwDg37yrbWgU5LS97+DU6dbMGVE3zPpuZGPZMTdXqzWWy2VlTPXMvAVt3Y4YG
-90hO1nDIwLn/1w9+Vb76b/5xc8AWWLozK4IPjh3pTvL6tCDiZw7tOQYp2uIO1Id1
-hKbb8cJaj/A6UsTE00yz5CUyQMcLz3LaL9k7Ek0u7vCcJLicl1HbAeq1ah7ePLLX
-6dM18fnfBc3yA4KI7AO8UAmRkTscMYV6f/K4YZR6ZYCNWRpY7rkg+arhf05aoSQf
-vn9bO1bzwdnG
+AQsFAAOCAYEAbTkg946BsGPQFX3jskBjwINeFnMP0IppuStonPQv3SNQu1SWP0xS
+o1Qji1dxkWDfOcp1ffrRMUo7ecrJbTqQ5Sdx+7zw0OLodSVqSu1LMIVDw/T73smg
+ADO2r3eZ8vxCKh7z4wUeKXvmBXi5NvpmvhH7D+qeG4OMLI8jnfmfbSHZQZbe2tpd
+tJC+MYVok/m91fBrfv5wqLsR5QiJl3vcVhG+xACd46gr3JZFOxBqpSJrCYL8Gwqx
+BaKEySCLGqkb0d1Rnt2/zTR2KtW2QJVH9rBMnJ+LsPEFKs1UHH4qHzxmwmmaQLon
+MoE4UJ51GHGrjJ4WsHOUSOy5UbjaQec3kuIDwTXKbHws0J0Ut9S4S38opZKdQHDD
+PUBpY0QA1CgE/VjKAYEDHOJyfUCNOl+sEESM+WxEXZAUVZLrFF7MljJqyQq+JyTD
+vFKHe1ZAA76NFrPscB/ODPTBK8i+u4gwrD1UAsVAHuIbOpQu4LYAujluCu5cl2A8
+HhmlCT7sTkqG
 -----END CERTIFICATE-----