2.39  2026-02-15

  - Keep distribution minimum Perl version unchanged while gating
    delpaths regression coverage to Perl 5.34+ runtimes.
  - Bump module version to 2.39.

2.38  2026-02-15

  - Normalize JSON::PP boolean decoding across supported runtimes and
    enforce delpaths boolean-index coverage in tests.
  - Bump module version to 2.38.

2.37  2026-02-14

  - Harden numeric extraction across aggregate functions to avoid
    spurious warnings with mixed-type arrays while preserving boolean
    1/0 handling.
  - Expand aggregate and percentile tests for mixed-value arrays and
    warning-free execution.
  - Bump module version to 2.37.

2.36  2026-02-14

  - Fix @uri encoding for decoded UTF-8 object input by avoiding
    unnecessary UTF-8 re-encoding of byte-oriented strings.
  - Expand UTF-8 regression coverage in t/decode_utf8_input.t for
    decoded UTF-8 scalar and object key/value encoding behavior.
  - Bump module version to 2.36.

2.35  2026-02-14
  - Fix map_values() to apply filters to scalar array elements.
  - Expand map_values() tests for scalar-array transform and filtering behavior.
  - Bump module version to 2.35.

2.34  2026-02-14
  - Accept whitespace around del() key arguments before unquoting.
  - Expand del() test coverage for whitespace, quoting, missing keys, and non-object passthrough.
  - Bump module version to 2.34.

2.33  2026-02-11
  - Strengthen @base64d validation to reject non-string scalar input.
  - Expand @base64d edge-case coverage for invalid alphabet, length, and padding.
  - Bump module version to 2.33.

2.32  2026-02-07

  - Reset runtime query variables per top-level run_query() call so
    query-local bindings (for example `. as $tmp`) do not leak across
    independent queries.

  - Preserve constructor-provided vars by introducing a base variable
    snapshot reapplied at each top-level query, while keeping nested
    run_query() evaluations in the same dynamic scope.

  - Add regression coverage in t/arg_option.t for query-local variable
    usage, non-leakage across top-level queries, and continued access
    to predeclared variables.

  - Bump module version to 2.32.

2.31  2026-02-07

  - Fix try/catch parsing so nested top-level try expressions do not
    incorrectly bind the outer catch clause.

  - Add regression coverage for nested try/catch handling with
    `try try (.num / .den) catch 7 catch 9`.

  - Bump module version to 2.31.

2.30  2026-02-07

  - Skip executing the delpaths boolean-segment array-index test on Perl
    versions 5.32 and below by moving the query execution inside the SKIP block.

  - Bump module version to 2.30.

2.29  2026-01-29

  - Treat only canonical numeric keys as array indices in from_entries so
    keys with leading zeros remain object keys, with added coverage.

  - Bump module version to 2.29.

2.28  2026-01-29

  - Unescape single-quoted assignment literals with embedded quotes and
    add coverage for single-quoted assignment values.

  - Bump module version to 2.28.

2.27  2026-01-22

  - Skip delpaths boolean index assertions on Perl versions older than 5.32.

  - Bump module version to 2.27.

2.25  2026-01-21

  - Normalize JSON boolean detection via JSON::PP::is_bool to ensure stable
    path handling on older Perl releases.

  - Bump module version to 2.25.

2.24  2026-01-21

  - Treat startswith()/endswith() as string-only predicates so numeric
    scalars and non-string arguments no longer match, with added coverage
    for numeric scalars, numeric string values, and numeric arguments.

  - Bump module version to 2.24.

2.23  2026-01-18

  - Skip ltrimstr()/rtrimstr() processing for non-string scalars so numbers
    and booleans remain unchanged, with expanded coverage for mixed arrays.

2.22  2026-01-17

  - Updated join() to stringify JSON boolean values as true and false, 
    instead of relying on implicit or inconsistent coercion.

  - Modified join() to error when encountering non-scalar elements (objects or arrays)
    within the input array, aligning behavior with jq for unsupported nested structures.

  - Expanded test coverage for join() to include:

  - Mixed scalar type coercion (string, number, boolean, null)

  - Proper error handling when object or array elements are present

2.21  2026-01-17

  - Fix delpaths handling for boolean-keyed segments and stable deletion
    ordering, with added test coverage for boolean paths.

2.20  2026-01-17

  - Validate has() array indices to require numeric scalar integers and add
    regression coverage for numeric-string and fractional inputs.

2.19  2026-01-17

  - Ensure try/catch parsing does not treat field names like .catch as a catch
    clause, and add regression coverage.

2.18  2026-01-16

  - Improve from_entries() to handle numeric keys by normalizing them to strings,
    allowing array indexes and numeric object keys to be processed correctly.

  - Add round-trip coverage for arrays via to_entries | from_entries, ensuring
    sequential numeric keys (0..n-1) are reconstructed as arrays rather than
    plain objects.

  - Add regression tests for numeric key handling in from_entries(), including
    non-sequential keys and collisions between "0" and 0 (last-write-wins).

2.17  2026-01-16

  - Normalize group_count() path handling to accept dotted paths and full-item
    grouping, with added coverage for those cases.

2.16  2026-01-15

  - Expand is_empty() coverage for non-collection inputs and non-empty
    collections.

2.15  2026-01-14

  - Treat null haystacks or needles in index()/rindex() string searches as
    null results.
  - Expand index()/rindex() tests for null input handling.

2.14  2026-01-12

  - Validate slice() start/length arguments and raise clear errors when
    non-numeric values are provided.
  - Expand slice() tests to cover invalid argument errors.

2.13  2026-01-12

  - Parse join() separators with the shared string argument decoder so
    escape sequences (like "\t" and "\n") are honored.
  - Expand join() tests to cover escaped separators.

2.12  2026-01-12

  - Add string scalar support to reverse() so it reverses plain strings while
    leaving non-string scalars unchanged.
  - Expand reverse() coverage for string and numeric-string inputs.

2.11  2026-01-12

  - Decode quoted field names with the shared JSON decoder for consistent
    behavior on older Perl versions.
  - Bump module version and documentation to 2.11.

2.10  2026-01-11

  - Improve mode() handling for nested values by generating recursive keys.
  - Add regression coverage for mode() with nested objects.

2.09  2026-01-11

  - Update contains() handling so null needles do not match non-null scalars.
  - Expand contains()/contains_subset() tests for null handling on strings.

2.08  2026-01-11

  - Updated match() to return jq-compatible match objects instead of booleans.
    The result now includes:
      * offset   — start position of the match
      * length   — length of the matched substring
      * string   — the full matched text
      * captures — array of capture group objects (offset, length, string)

  - match() now returns null when the regular expression does not match,
    aligning behavior with jq.

  - This enables jq-style regex introspection such as accessing capture
    groups (e.g. match("(...)(...)").captures[1].string).

2.07  2026-01-11

    - Enforced validation of regular expression flags for test() and match()
      so unknown flags (e.g. "z") now raise a runtime error instead of being
      silently ignored.

    - Added regression coverage ensuring invalid regex flags are rejected
      consistently in both test and match filters.

2.06  2026-01-11

    - Treat JSON string scalars as strings during addition and throw on
      mixed string/number operands.

2.05  2026-01-11

    - Fix value parsing so string literals containing "contains" are not
      misinterpreted as a contains condition.

2.04  2026-01-11

    - Fix try/catch parsing to ignore catch tokens inside literals.

2.03  2026-01-11

    - Ensure try/catch can return empty results without forcing null output.

2.02  2026-01-10

    - Fix bracketed array/index access parsing so expressions like .[0]
      remain traversal expressions instead of array constructors.
    - Add CLI regression coverage for compact output array indexing.

2.01  2026-01-10

    - Fixed quoted field access so expressions like ."k" and ."a b"
      are correctly parsed as key paths instead of string literals.

    - Added proper decoding and traversal support for quoted keys,
      allowing access to object fields containing spaces or dots.

    - Added regression tests covering quoted field access behavior.

2.00  2026-01-10

    - Fix group_by() to evaluate the key per element and form correct
      groups instead of collapsing everything into one.
    - Enforce array input for group_by() and add regression tests
      covering scalar, array, and null keys.
    - Note: quoted field access (."k") is still parsed as a string literal
      and may affect expressions like group_by(."k") (tracked separately).

1.99  2026-01-10

    - Promote release to version 1.99 expanding test coverage for regex
      flags in test() and match() and their default behaviors.

1.98  2026-01-06

    - Promote release to version 1.98 capturing stricter join() input
      validation and coverage for null elements to align behavior with jq.

1.97  2026-01-05

    - Promote release to version 1.97 restoring jq-compatible flatten behavior:
      depth-based array flattening while keeping .[] traversal separate.
    - Preserve null outputs through map(... ) | flatten flows (no silent drops),
      and expand tests covering passthrough and the null regression scenario.

1.96  2026-01-05

    - Promote release to version 1.96 capturing the substr argument
      validation updates and expanded negative test coverage.

1.95  2026-01-05

    - Promote release to version 1.95 covering substr boolean stringification
      before slicing and expanded regression tests for scalar/array cases.

1.94  2026-01-05

    - Promote release to version 1.94 capturing the init-expression
      fallback fixes for foreach/reduce and the expanded test coverage
      around filtered initializers.

1.93  2026-01-05

    - Promote release to version 1.93 covering the stricter invalid regex
      handling for match conditions and the accompanying regression tests.

1.92  2026-01-05

    - Promote release to version 1.92 capturing improved split handling
      for boolean values and mixed arrays, with accompanying test coverage.
    - Ensure split returns flat arrays when applied to arrays, avoiding
      nested results for boolean and string elements.

1.91  2026-01-05

    - Promote release to version 1.91 covering string scalar flattening
      improvements and expanded test coverage.

1.90  2026-01-05

    - Promote release to version 1.90 including argument validation for
      drop(), tail(), and chunks() along with expanded slice tests.

1.89  2026-01-05

    - Release version 1.89 with stricter limit() validation and expanded
      tests covering invalid arguments.

1.88  2026-01-05

    - Promote release to version 1.88 including the invalid regex error
      handling improvements and additional test coverage.

1.87  2026-01-05

    - Clarified and enforced usage errors when --raw-input is used without
      a filter expression, including distinct diagnostics for standalone
      and --slurp modes.
    - Added CLI regression tests to lock in exit code 5 and the expected
      usage messages for missing-query scenarios.

1.86  2026-01-05

    - Refined the count filter to operate per input value, correctly handling
      streamed inputs and nested arrays without implicit aggregation.

    - Expanded count test coverage to validate stream semantics, including
      objects, scalars, null values, and composed pipelines.


1.85  2026-01-05

    - Hardened range() argument validation to reject booleans, references,
      and numeric-looking strings instead of silently coercing them.
    - Expanded range tests to cover invalid bounds and step values,
      ensuring runtime errors are raised consistently.

1.84  2026-01-05

    - Promote release to version 1.84 incorporating stricter path element
      validation and expanded coverage for setpath() and delpaths().

1.83  2026-01-05

    - Promote release to version 1.83 capturing the compile-time validation
      improvements for empty comma-separated filters and expanded CLI
      contract coverage.

1.82  2026-01-04

    - Ignore SIGPIPE in CLI to avoid premature termination when pipes are closed
      early, stabilizing CLI behavior

1.81  2026-01-04

    - Promote release to version 1.81 including the type() handling
      updates for scientific notation and numeric-looking strings.

1.80  2026-01-04

    - Promote release to version 1.80 reflecting normalized boolean path
      traversal handling in getpath.

1.79  2026-01-04

    - Promote release to version 1.79 including the boolean handling
      improvements for numeric rounding helpers and expanded coverage.

1.78  2026-01-04

    - Promote release to version 1.78 after tightening percentile
      validation and extending test coverage.

1.77  2026-01-04

    - Promote release to version 1.77 aligning with the expanded
      percentile test coverage.

1.76  2026-01-04

    - Promote release to version 1.76 reflecting the updated version
      output.

1.75  2026-01-03

    - Promote release to version 1.75 including the expanded
      --help-functions output that lists all supported built-ins.

1.74  2026-01-03

    - Improved POD documentation to clarify jq compatibility and intended use cases
      in environments where the jq binary cannot be installed.

    - No functional changes.

1.73  2026-01-03

    - Guard the CLI broken pipe contract test against SIGPIPE so runs on
      Perl 5.16 no longer abort with missing TAP output.

1.72  2026-01-03

    - Suppress EINVAL warnings when flushing STDOUT on broken pipes in
      older Perl versions.

1.71  2026-01-03

    - Preserve comparison filters during parsing so conditional branches
      evaluate paths like `.score >= 70` correctly.
    - Avoid treating map/object filters with comparisons as arithmetic
      expressions while still recognizing standalone comparison queries.

1.70  2026-01-03

    - Release jq-compatible `paths` and `paths(scalars)` filters and
      document scalar input behavior.

1.69  2026-01-03

    - Promote release to 1.69 documenting jq-compatible wildcard
      iteration over object values.

1.68  2025-12-27

    - Enforce jq-style runtime errors when setpath or delpaths receive
      non-array path arguments.
    - Verified the full test suite passes after path validation changes.

1.67  2025-12-27

    - Enforce jq-style runtime errors in from_entries for non-array inputs,
      malformed entries, missing values, and non-string keys.

1.66  2025-12-27

    - Enforce jq-style runtime errors when getpath is called with a
      non-array path argument.

1.65  2025-12-27

    - Align `keys` with jq by returning array indices and raising runtime
      errors on non-array/non-object inputs.

1.64  2025-12-27

    - Add jq-compatible --argfile CLI support, decoding JSON files into
      variables with usage errors for invalid JSON and input errors for
      unreadable files.

1.63  2025-12-27

    - Promote release to version 1.63 adding jq-compatible --slurpfile
      support that decodes JSON files into array-wrapped variables with
      consistent usage error handling for missing files and invalid JSON.

1.62  2025-12-27

    - Improved CLI error handling:
      Getopt::Long diagnostics are now captured and re-emitted
      with consistent [USAGE] prefixes and exit code 5,
      preventing raw warnings from leaking to stderr.

1.61  2025-12-27

    - Bump version to document the compile-error handling improvements
      for empty pipeline segments in jq-lite CLI queries.

1.60  2025-12-26

    - Align jq-lite CLI error handling with documented prefixes and
      exit codes, validating JSON input before execution and treating
      empty query results as success.

1.59  2025-12-26

    - Split utility helpers into dedicated parsing, path, and transform
      modules while keeping the main Util loader lightweight.

1.58  2025-12-25

    - Parse assignment right-hand sides using the expression evaluator
      so jq variables and expressions resolve correctly when assigning
      new values.
    - Pass the jq instance into assignment resolution to allow
      variable-aware evaluation and nested query execution.
    - Add a regression test covering assignment from a jq variable.

1.57  2025-12-24

    - Add opt-in contains_subset() providing jq-style array subset
      containment (order-insensitive with multiset matching) while
      preserving legacy contains() semantics for arrays.
    - Document the new array subset helper and clarify default array
      behavior for contains().
    - Cover subset array matching and nested array/object combinations
      with regression tests.

1.56  2025-12-24

    - Parse contains/inside arguments as literal JSON values so null
      survives argument parsing and matches null inputs.
    - Extend contains/inside containment checks to treat null inputs as
      matching null containers and add coverage for the behavior.

1.55  2025-12-21

    - Fix CLI smoke tests to reliably locate and execute jq-lite during
      build and test phases, including AUR and other isolated build
      environments.

1.54  2025-12-21

    - Add CLI smoke tests covering common jq-lite usage patterns.
    - Validate and fix SYNOPSIS examples to match tested behavior.
    - Confirm correct operation of core filters such as map, sort,
      sort_by, first, keys, and length on arrays and objects.
    - Standardize raw-input examples using '-R -s' for split processing.

1.53  2025-12-21
    - Rewrite the jq-lite man page with a concise, task-focused summary
      geared for quick CLI usage.

1.52  2025-12-20
    - Add jq-compatible --rawfile CLI option that loads file contents into
      variables for downstream filters, along with regression tests and
      documentation updates.

1.51  2025-12-20
    - Ignore SIGPIPE in the from_file_stdin test helper so closed pipes
      from the CLI under test do not terminate the harness.

1.50  2025-12-18
    - Promote release to version 1.50.
    - Allow CLI JSON encoding to accept scalar values when processing
      --argjson and raw input modes, eliminating warnings and exit failures.
    - Consolidate raw-input handling under a shared UTF-8 encoder to keep
      per-line and slurped text output consistent.

1.49  2025-12-17
    - Allow t/path.t to skip cleanly on Perl 5.28 and earlier by removing
      the hard 5.029 requirement.

1.48  2025-12-17
    - Added jq-compatible --ascii-output / -a flag for ASCII-escaped output.
    - Note: Interaction with -r (raw output) and -R (raw input) will be refined in a follow-up release.

1.47  2025-12-15
    - Promote release to version 1.47 adding jq-compatible --raw-input/-R
      plain-text processing with optional slurping and CLI regression tests.

1.46  2025-12-14
    - Promote release to version 1.46 with jq-compatible try/catch filter
      support, documentation, and regression tests.

1.45  2025-12-13
    - Promote release to version 1.45 adding jq-compatible --argjson CLI support.

1.44  2025-11-10
    - Promote release to version 1.44 including the jq-compatible rest filter.

1.43  2025-11-09
    - Release jq-compatible @base64d formatter with documentation and tests.

1.42  2025-11-09
    - Release jq-compatible ascii_upcase filter along with docs and tests.

1.41  2025-11-08
    - Allow jq-lite --from-file/-f to load filters from STDIN while keeping
      JSON input separate from the shared handle.
    - Document the new STDIN support in the CLI usage text and add regression
      tests for the feature.

1.40  2025-11-08
    - Release jq-compatible ascii_downcase filter along with docs and tests.

1.39  2025-11-08
    - Add jq-compatible --arg option to the CLI and wire variables into the engine.
    - Allow passing initial variables when constructing JQ::Lite instances.
    - Document the new option and add regression tests for variable access.

1.38  2025-11-08
    - Release jq-compatible @json formatter support with documentation and tests.

1.37  2025-11-02
    - Release parenthesized pipeline evaluation improvements in expressions.

1.36  2025-11-02
    - Release jq-compatible @uri formatter and percent-encoding helper.
    - Declare Encode dependency and document formatter usage.

1.35  2025-11-01
    - Release base64 formatter support and dependency metadata updates.

1.34  2025-11-01
    - Publish homepage metadata updates for CPAN distribution listings.

1.33  2025-11-01
    - Skip YAML-related test on Perl 5.20–5.26 due to known incompatibility issues.
    - Updated test comments to English for consistency and clarity.

1.30  2025-10-25
  [Feature]
  - Add a jq-compatible @tsv formatter for tab-separated output with
    proper escaping of arrays and scalar values.

  [Release]
  - Bump version to 1.30.

1.29  2025-10-25
  [Feature]
  - Add jq-compatible comma sequence handling so each branch runs against the
    same input value and streams its results in order.

  [Tests]
  - Expand comma regression coverage to exercise chaining, optional access,
    array/object constructors, and syntax errors.

  [Release]
  - Bump version to 1.29.

1.28  2025-10-25
  [Feature]
  - Add a jq-compatible @csv filter for formatting scalars and arrays as
    CSV output.

1.27  2025-10-24
  [Release]
  - Bump version to 1.27 to publish the select() predicate evaluation fixes.

1.26  2025-10-24
  [Behavior]
  - Run select() predicates as streaming filters so inputs pass once for each
    truthy predicate result while preserving compatibility with comparison
    expressions.

1.25  2025-10-23
  [CLI]
  - Fix YAML input handling in jq-lite: allow scalar (non-ref) results to be
    encoded without warnings or failure by adding `allow_nonref` to the
    JSON::PP encoder in `print_results`. This resolves failures in
    t/yaml_cli.t:
      * YAML files auto-detected by extension now work as expected.
      * No warnings are emitted when parsing YAML (file or STDIN with --yaml).
      * Process exits successfully (status 0) on valid YAML input.
    (PR: GH#XX)

  [Behavior]
  - Output behavior for JSON inputs is unchanged; raw/compact/color options
    continue to work as before. YAML input is first converted to JSON and
    scalar top-level values are now treated correctly.

  [Internals]
  - Minimal code change: `JSON::PP->new->utf8->allow_nonref->canonical`
    in `print_results`.

1.24  2025-10-22
    [Tests]
    - Rewrite t/yaml_cli.t to remove dependency on YAML::XS.
      The test now parses YAML via core CPAN::Meta::YAML and converts
      it to JSON with core JSON::PP before invoking jq-lite.
      This makes the test suite pass on Perl 5.24 and 5.26 where
      YAML::XS may be unavailable and JSON::PP requires hash/array refs.
    - Stop asserting "YAML files are auto-detected by extension" and
      the --yaml STDIN path in this test; those behaviors are now
      independent of YAML::XS and no longer required for this file.
      (Runtime autodetection/--yaml can be covered by a separate,
      optional test when YAML::XS is present.)
    - Add small helpers and stricter assertions; ensure no spurious
      warnings are emitted when feeding JSON to jq-lite.

1.23  2025-10-21
    - Allowed the CLI’s JSON encoder to handle scalar values when printing results,
      eliminating YAML processing warnings on older Perl versions.

1.22  2025-10-20
    [Fixes]
    - Ensure nested filter helpers and the CLI YAML decoder encode scalars
      with `allow_nonref` so Perl 5.20 no longer dies on scalar documents.

1.21  2025-10-20
    [Fixes]
    - Allow `tojson` to encode scalar values by configuring JSON::PP with
      `allow_nonref`, restoring compatibility with Perl 5.22.

1.20  2025-10-19
    [Feature]
    - Introduce a dedicated arithmetic expression engine with numeric operators,
      precedence-aware parsing, and builtin math helpers.

    [Maintenance]
    - Ensure expression evaluation defers to existing filter handlers for
      non-math builtins so prior queries remain compatible.

1.19  2025-10-19
    - Fixed Kwalitee issue: "no_files_to_be_skipped"
    - Updated MANIFEST.SKIP to correctly preserve META.json while excluding other JSON files
    - Ensured proper handling of .git/, .github/ and temporary files
    - Rebuilt META.json and MANIFEST to align with CPAN packaging standards
    - No functional code changes; this release focuses on distribution quality improvements

1.18   2025-10-19
    [Maintenance]
    - Bump version to 1.18.

1.17   2025-10-19
    [Feature]
    - Add optional YAML parsing to the jq-lite CLI via a --yaml flag and
      automatic .yml/.yaml detection.

    [Docs]
    - Document YAML workflows, module fallbacks, and examples in the README.

    [Tests]
    - Add CLI regression coverage that exercises YAML input handling.

1.16   2025-10-18
    [Fixes]
    - Configure the shared JSON::PP decoder with `allow_nonref` so Perl 5.22.3
      environments accept scalar-only documents without dying.

1.15   2025-10-18
    [Feature]
    - Implement jq-compatible addition handling so `+` performs numeric sums
      and string concatenations across filters and value expressions.

    [Tests]
    - Extend arithmetic coverage to assert array mapping and concatenation
      queries that rely on addition semantics.

1.14   2025-10-18
    [Fixes]
    - Expand jq-style object constructor shorthand (e.g. `{name, age}`) to
      explicit key/value pairs so map projections emit the expected hashes.
    - Ensure `map(...)` evaluates its filter against each array element,
      allowing comparisons like `(.age >= 20)` to yield booleans instead of
      null.

    [Tests]
    - Extend the map regression coverage to lock in shorthand object
      projections and boolean evaluation on each element.

1.13   2025-10-18
    [Feature]
    - Promote the release to 1.13 to ship jq-style object constructors so
      filters like `{ "name": .name }` emit hashes for each pipeline item.

    [Tests]
    - Include regression coverage for object constructor queries to lock in the
      new behavior.

1.12   2025-10-18
    [Feature]
    - Added jq-compatible array constructors so filters like `[.name, .age]`
      emit collected values for each input.

    [Tests]
    - Added regression coverage for array construction, including empty
      constructors and multi-value element expressions.

1.11   2025-10-18
    [Feature]
    - Added jq-compatible `--from-file` (`-f`) option so filters can be read
      from standalone jq scripts instead of the command line.

    [Tests]
    - Added CLI regression coverage ensuring queries loaded from files execute
      successfully and honor `--null-input` constraints.

    [Docs]
    - Documented the new `--from-file` flag across README and CLI usage text.

1.10   2025-10-18
    [Feature]
    - Added jq-style `if ... then ... elif ... else ... end` conditional
      expressions so queries can branch using familiar jq syntax, including
      cascading elif clauses and optional fallbacks.

    [Tests]
    - Added regression coverage for if/elif/else handling, including nested
      branches and expressions without an else clause.

    [Docs]
    - Documented conditional expressions across README, module POD, and the CLI
      help output.

1.09   2025-10-18
    - Promote the release version to 1.09 after adding jq-compatible
      foreach folding and test() helper support.

1.08   2025-10-18
    [Feature]
    - Added jq-compatible `foreach expr as $var (init; update [; extract])`
      folding with optional emitters so streaming reductions mirror jq.
    - Added jq-compatible `--slurp` (`-s`) option to wrap every JSON document
      from the input stream in a single array before executing filters.
    - Added jq's `test(pattern[, flags])` helper for regex matching with
      optional `imxs` modifiers.

    [Tests]
    - Added regression coverage ensuring foreach accumulates values and
      supports extract expressions referencing the iteration variable.
    - Added tests covering regex matches, flag handling, and array mapping via
      the new test() helper.

    [Docs]
    - Documented foreach across README, module POD, and CLI helper listings.
    - Documented test() in README, POD, and CLI help output.

1.06   2025-10-18
    - Added jq-compatible `--compact-output` (`-c`) flag to emit single-line
      JSON results from the jq-lite CLI.

1.05   2025-10-18
    - Added jq-style reduce syntax (`reduce expr as $var (init; update)`) with
      lexical variable bindings and `. +` arithmetic support.

1.04   2025-10-18
    [Features]
    - Added jq-compatible --null-input (-n) option to jq-lite so filters can
      run against null without providing input data.
    - Implemented jq's setpath(path; value) helper to create/update nested
      structures using literal paths or filter-generated path arrays.

    [Refactor]
    - Refactored JQ::Lite to delegate query parsing and filter execution to
      dedicated modules, keeping only orchestration logic in the main package.
    - Introduced JQ::Lite::Parser to normalize query strings before execution,
      handling trimming and shorthand conversions such as `.[]` into flatten
      semantics.
    - Centralized jq-style filter implementations in JQ::Lite::Filters, wiring
      each command to shared utility routines and standardizing result handling.
    - Moved shared helper functions into JQ::Lite::Util, consolidating common
      operations like assignments, traversal, and numeric utilities.

    [Maintenance]
    - Improved internal structure for clarity, maintainability, and easier
      extension of jq-compatible features in future releases.
    - No user-facing behavior changes; this refactor is fully backward
      compatible.

1.02   2025-10-16
    [Maintenance]
    - Promote the release version to 1.02 to ensure Perl's version parsing
      keeps this release newer than the historical 0.99.
    [Feature]
    - Added fromjson() helper to decode JSON text back into native data
      structures, mirroring jq's behaviour and complementing tojson().
    - Implemented jq's `//` alternative operator so pipelines can fall back to
      secondary expressions when the primary value is null or missing.
    [Tests]
    - Added regression coverage asserting fromjson() handles objects, arrays,
      invalid JSON text, and null propagation.
    - Added coalesce-focused regression tests covering literals, booleans, and
      chained fallbacks.
    [Docs]
    - Documented fromjson() across README, CLI helper listings, and module POD.
    - Documented the new alternative operator in README, CLI help, and module
      POD alongside examples.

1.01   2025-10-16
    [Maintenance]
    - Promote the release version to 1.01 to ensure Perl's version parsing
      keeps this release newer than the historical 0.99.
    [Feature]
    - Added fromjson() helper to decode JSON text back into native data
      structures, mirroring jq's behaviour and complementing tojson().
    [Tests]
    - Added regression coverage asserting fromjson() handles objects, arrays,
      invalid JSON text, and null propagation.
    [Docs]
    - Documented fromjson() across README, CLI helper listings, and module POD.

0.104  2025-10-13
    [Feature]
    - Added assignment support for simple jq-style expressions such as
      `.path = value`, allowing in-place updates of decoded data structures
      within pipelines.
    [Tests]
    - Added regression coverage for assignments across scalars, nested hashes,
      arrays, and null literals.

0.103  2025-10-13
    [Feature]
    - Added recurse helper mirroring jq's recurse/0 and recurse/1 to emit the
      current value alongside depth-first descendants using optional child
      filters.
    [Tests]
    - Added regression coverage ensuring recurse() traverses nested objects,
      arrays, and custom child relationships.
    [Docs]
    - Documented recurse across README, module POD, and CLI helper listings.

0.102  2025-10-13
    [Feature]
    - Added not helper mirroring jq's logical negation semantics, yielding
      JSON booleans based on jq-lite's truthiness rules across scalars,
      arrays, and objects.
    [Tests]
    - Added regression coverage ensuring not() inverts truthiness for
      booleans, nulls, arrays, and objects.
    [Docs]
    - Documented not across README, module POD, and CLI helper listings.

0.101  2025-10-13
    [Feature]
    - Added scalars helper mirroring jq's scalars/0 filter to pass through only
      scalar inputs while skipping arrays and objects.
    [Tests]
    - Added regression coverage ensuring scalars() keeps strings, numbers,
      booleans, and nulls while dropping containers.
    [Docs]
    - Documented scalars across README, module POD, and helper listings.

0.100  2025-10-13
    [Feature]
    - Added objects helper mirroring jq's objects/0 filter to pass through only
      hash inputs while skipping scalars and arrays.
    [Tests]
    - Added regression coverage ensuring objects() mirrors jq semantics for
      arrays, scalars, and nested objects.
    [Docs]
    - Documented objects across README, module POD, helper listings, and
      updated MANIFEST.

0.99  2025-10-13
    [Feature]
    - Added arrays helper mirroring jq's arrays/0 filter to pass through only
      array inputs while dropping scalars and objects.
    [Tests]
    - Added regression coverage ensuring arrays() filters pipelines and
      non-array inputs as jq does.
    [Docs]
    - Documented arrays across README, module POD, CLI helper listings, and
      updated MANIFEST.

0.98  2025-10-13
    [Feature]
    - Added rindex(value) helper mirroring jq's rindex/1 to locate the final
      occurrence of a value within arrays (deep comparing elements) or strings.
    [Tests]
    - Added regression coverage ensuring rindex() handles arrays of scalars,
      nested hashes, booleans, empty fragments, and missing values.
    [Docs]
    - Documented rindex() across README, module POD, CLI help listings, and
      updated MANIFEST.

0.97  2025-10-12
    [Feature]
    - Added getpath(path_expr) helper mirroring jq's getpath/1 to retrieve
      values from literal path arrays or dynamically generated paths.
    [Tests]
    - Added regression coverage ensuring getpath handles nested hashes, array
      indices (including negatives), boolean values, and filter-produced paths.
    [Docs]
    - Documented getpath() in README, module POD, CLI helper listings, and
      updated MANIFEST.

0.96  2025-10-12
    [Feature]
    - Added leaf_paths() helper mirroring jq's paths(scalars) traversal to
      emit only terminal key/index chains.
    [Tests]
    - Added regression coverage for leaf_paths() to ensure arrays, objects,
      and scalars produce the correct terminal paths.
    [Docs]
    - Documented leaf_paths() in README, module POD, and CLI helper listings.

0.95  2025-10-12
    [Feature]
    - Added walk(filter) helper to recursively traverse arrays and objects while
      applying jq-compatible filters to every value.
    [Tests]
    - Added regression coverage for walk() to ensure nested scalars and arrays
      are transformed recursively.
    [Docs]
    - Documented walk() across README, POD, and --help-functions listings.

0.94  2025-10-12
    [Feature]
    - Added all([filter]) helper mirroring jq's all/0 and all/1 semantics for
      truthiness checks across arrays and scalars.
    [Tests]
    - Added regression coverage for all() with and without filters, including
      edge cases for empty arrays and scalar inputs.
    [Docs]
    - Documented the new helper across README, POD, and --help-functions
      listings.

0.93  2025-10-12
    [Feature]
    - Added tojson() helper to encode any value as JSON text, mirroring jq's
      tojson/0 behavior and complementing existing tostring(). Documented the
      helper across README, POD, CLI help, and regression tests.
    [Tests]
    - Added regression coverage for tojson() to ensure strings, numbers,
      booleans, nulls, arrays, and objects emit the expected JSON text.
    [Docs]
    - Documented tojson() across README, POD, CLI help listings, and function
      tables alongside existing string helpers.
    - Added delpaths(paths) helper to delete multiple keys or indices using
      jq-compatible path arrays evaluated via arbitrary filters. Updated the
      documentation and regression tests accordingly.

0.92  2025-10-11
    [Feature]
    - Added map_values(filter) helper to transform every value within objects
      using jq-compatible filter semantics, dropping keys when the filter
      yields no result and recursing through arrays of objects. Documented the
      helper across README, POD, CLI help, and regression tests.

0.91  2025-10-11
    [Feature]
    - Added indices(value) helper to emit every index where the supplied value
      occurs within arrays or strings, matching jq's behaviour for substring and
      element searches. Documented the helper across README, POD, CLI help, and
      regression tests.

0.90  2025-10-11
    [Feature]
    - Added any([filter]) helper to mirror jq's any/0 and any/1 behaviour for
      truthiness checks over arrays and scalars, including nested filter
      evaluation. Documented the helper across README, POD, CLI help, and
      regression tests.

0.89  2025-10-11
    [Feature]
    - Added paths() helper to enumerate every nested key/index path in objects,
      arrays, and scalars (empty path) matching jq's behaviour.
    - Documented the helper across README, POD, and regression tests.

0.88  2025-10-11
    [Feature]
    - Added explode() and implode() helpers to convert between strings and
      arrays of Unicode code points, mirroring jq's functions and handling
      nested arrays element-wise.
    - Documented the helpers across README, POD, and regression tests.

0.87  2025-10-11
    [Feature]
    - Added ltrimstr(prefix) and rtrimstr(suffix) helpers to remove literal
      prefixes/suffixes from strings while preserving non-matching values and
      recursively processing arrays.
    - Documented the helpers across README, POD, CLI help, and regression tests.

0.86  2025-10-11
    [Feature]
    - Added range(start; end[, step]) helper to emit numeric sequences matching
      jq's range function, including descending and custom step behavior.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.85  2025-10-11
    [Feature]
    - Added tostring() helper to convert values into their JSON string form,
      matching jq's behavior for scalars, booleans, null, arrays, and objects.
    - Documented the helper across README, POD, CLI help, and regression tests.
    - Added keys_unsorted helper to expose jq's unsorted key traversal for
      objects, along with documentation and regression tests.

0.84  2025-10-11
    [Feature]
    - Added to_entries(), from_entries(), and with_entries(filter) helpers to
      round out jq's entry transformation workflow for objects and arrays.
    - Documented the helpers across README, POD, CLI help, and regression tests.

0.83  2025-10-11
    [Feature]
    - Added median_by(path) helper to compute the median of numeric values
      projected from array elements, mirroring the semantics of median.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.82  2025-10-11
    [Feature]
    - Added percentile(p) helper to compute linear-interpolated percentiles for
      numeric array values.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.81  2025-10-11
    [Feature]
    - Added enumerate() helper to pair array elements with their zero-based
      index for downstream processing.
    - Documented the helper across README, POD, CLI help, and regression tests.
    - Added transpose() helper to pivot arrays-of-arrays from rows into
      columns, truncating to the shortest length for uneven input.

0.80  2025-10-11
    [Feature]
    - Added merge_objects() helper to flatten arrays of hashes into a single
      object using last-write-wins semantics while ignoring non-object entries.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.79  2025-10-11
    [Feature]
    - Added tail(n) helper to return the last N elements from arrays while
      preserving shorter inputs unchanged.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.78  2025-10-11
    [Feature]
    - Added avg_by(path) helper to compute the arithmetic mean of numeric values
      projected from each array item, mirroring the behavior of sum_by.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.77  2025-10-10
    [Feature]
    - Added variance helper to compute the average squared deviation of numeric
      array values.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.76  2025-10-10
    [Feature]
    - Added mode helper to return the most frequent array value with stable
      tie-breaking based on first appearance.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.75  2025-10-09
    [Feature]
    - Added min_by(path) and max_by(path) helpers to select array elements with
      the smallest or largest projected value.
    - Documented the helpers across README, POD, CLI help, and regression tests.

0.74  2025-10-08
    [Feature]
    - Added pick(key1, key2, ...) helper to build objects that only include the
      requested keys, with array-aware behavior for bulk selection.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.73  2025-10-05
    [Feature]
    - Added clamp(min, max) helper to constrain numeric values within an
      inclusive range while leaving non-numeric data untouched.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.72  2025-10-05
    [Feature]
    - Added to_number() helper to coerce numeric-looking strings and booleans
      into Perl numbers while preserving non-numeric values.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.71  2025-10-05
    [Feature]
    - Added has(key) helper to verify object keys and array indexes.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.70  2025-10-05
    [Feature]
    - Added flatten_depth(n) helper to flatten nested arrays up to a specified
      depth while preserving deeper structure.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.69  2025-10-05
    [Feature]
    - Added titlecase() helper to convert scalars and arrays to title case.
    - Documented the helper across README, POD, CLI help, and regression tests.

0.68  2025-10-05
    [Feature]
    - Added sum_by(path) helper to aggregate numeric values from array items.
    - Documented the helper across README, POD, CLI help, and tests.

0.67  2025-10-05
    [Feature]
    - Added flatten_all() helper to recursively flatten nested arrays.
    - Documented the helper across README, POD, CLI help, and tests.

0.66  2025-10-05
    [Feature]
    - Added slice(start[, length]) helper to extract portions of arrays using
      zero-based indices (including support for negative starts).
    - Documented the helper across README, POD, CLI help, and tests.

0.65  2025-10-05
    [Feature]
    - Added index(value) helper to return the first matching index for arrays or
      substring position for scalars.
    - Documented the helper across README, POD, CLI help, and tests.

0.64  2025-10-05
    [Feature]
    - Added chunks(n) helper to split arrays into evenly-sized subarrays.
    - Documented the helper across README, POD, CLI help, and tests.

0.63  2025-10-05
    [Feature]
    - Added drop(n) helper to skip the first N elements of arrays.
    - Documented the helper across README, POD, CLI help, and tests.

0.62  2025-10-05
    [Feature]
    - Added stddev helper to calculate the standard deviation of numeric array
      values.
    - Documented the helper across README, POD, and --help-functions output.
    - Added regression tests covering numeric, mixed, and single-value inputs.

0.61  2025-10-05
    [Feature]
    - Added sort_desc helper to sort arrays in descending order using smart
      numeric/string comparisons.
    - Documented the helper across README, POD, and --help-functions output.
    - Added regression tests covering numeric, string, and numeric-string values.

0.60  2025-10-05
    [Feature]
    - Added unique_by(key) helper to deduplicate arrays based on projected keys.
    - Documented the helper across README, POD, and --help-functions output.
    - Added regression tests covering scalar, object, and nested-key scenarios.

0.59  2025-10-05
    [Feature]
    - Added product helper to multiply numeric array values.
    - Documented the helper across README, POD, and --help-functions output.
    - Extended aggregation tests to cover the new helper.

0.58  2025-10-05
    [Feature]
    - Added sum helper as an alias for add to provide jq-compatible naming.
    - Documented the new helper across README, POD, and --help-functions output.
    - Extended aggregation tests to cover the new function.

0.57  2025-10-04
    [Feature]
    - Added substr(start, length) helper to extract substrings from scalars and
      arrays of strings.
    - Documented the new function in README, POD, and --help-functions output.
    - Added regression tests covering basic usage, negative indices, arrays,
      and null-safe behavior.

0.56  2025-10-04
    [Feature]
    - Added contains() function for substring, array element, and hash key checks.
    - Documented the new helper and covered it with regression tests.

0.55  2025-10-04
    [Feature]
    - Updated length function to return character counts for scalars in addition to
      array elements and hash keys.

0.54  2025-10-04
    - Added round() helper for rounding numbers (and arrays) to the nearest integer.
    - Documented the new function in README, POD, and --help-functions output.
    - Added regression tests covering scalars, nested arrays, and mixed values.

0.53  2025-10-04
    - Added ceil()/floor() helpers for rounding numeric scalars and arrays.
    - Documented the new functions in README, POD, and --help-functions output.
    - Added regression tests for positive/negative values and nested arrays.

0.52  2025-10-04
    - Added split() helper for splitting string values by a literal separator.
    - Documented the new function in README, POD, and --help-functions output.
    - Added regression tests covering scalar strings, nested arrays, and edge cases.

0.51  2025-10-04
    - Added startswith()/endswith() helpers for prefix and suffix checks on
      scalars and arrays of strings.
    - Documented the new functions and listed them in README and --help-functions output.
    - Added regression tests covering scalars, arrays, mixed values, and chained usage.

0.50  2025-10-04
    - Added trim() helper to remove leading/trailing whitespace from strings
      and array elements recursively.
    - Documented the new function and included it in the --help-functions
      listing and README feature table.
    - Added regression tests covering scalar, array, and mixed inputs.

0.49  2025-10-04
    - Added abs() helper to convert numbers (and arrays of numbers) to their
      absolute values.
    - Documented the new function and listed it in --help-functions output.
    - Added regression tests covering scalar and array usage.

0.48  2025-10-04
    - Updated the --help-functions listing to cover every built-in helper.
    - Bumped version number for the 0.48 release.

0.47  2025-10-04
    - Added upper()/lower() helpers for case conversion of scalars and arrays.
    - Documented the new functions and listed them in --help-functions output.
    - Added regression tests covering scalar, array, and pipeline scenarios.

0.46  2025-10-04
    - Added group_count(key) helper to tally grouped results.
    - Documented the new function and added regression tests.

0.45  2025-10-04
    - Added median() aggregation helper with numeric filtering using looks_like_number().
    - Documented the median function and added dedicated tests covering mixed numeric formats.
    - Updated MANIFEST and module documentation for the new release.

0.44  2025-10-04
    - Prepare release for version 0.44.
    - Added standalone LICENSE file and included it in MANIFEST for kwalitee compliance.

0.42  2025-04-28
    - Added new function: default(value)
      * default() returns the specified value if the current value is undef or null.

0.41  2025-04-28
    - Added new function: is_empty()
      * is_empty() returns true if a value is an empty array or an empty object.

0.40  2025-04-28
    - Added new function: path()
      * path() returns the keys of a hash or the indices of an array.
      * Returns an empty string for scalars or null values.
    - Bump version to 0.40

0.39  2025-04-27
    - Added compact() function to remove undef/null values from arrays

0.38  2025-04-27
    - Added del(key) function to delete specific keys from hash objects

0.37  2025-04-27
    - Added nth(n) function to extract the nth element from an array

0.36  2025-04-27
    - Added type() function to determine JSON value type (string, number, boolean, array, object, null)
    - Improved handling of undefined values in type() function
    - Added test file t/type.t

0.35  2025-04-16
    - Added flatten() function to explicitly flatten arrays (equivalent to .[])
    - flatten() performs 1-layer array flattening like jq
    - Added test file t/flatten.t

0.34  2025-04-15
    - Added --help-functions option to display supported built-in functions
    - Added values() function to extract values from hash references
    - Improved MANIFEST handling with MANIFEST.SKIP for cleaner packaging
    - Minor test adjustments and documentation updates

0.33  2025-04-14
    - Added empty() function (compatible with jq, discards all output)
    - Example: .users[] | select(.age > 25) | empty
    - Useful for pipelines where only side effects are needed

0.32  2025-04-13
    - Added support for sort_by(.key) function to sort arrays of objects
      Example: .users | sort_by(.age)
    - Fixed path handling in sort_by() (leading dot now handled correctly)
    - Improved internal comparison logic with _smart_cmp()
    - Added test script t/sort_by.t to verify sort_by() functionality

0.31  2025-04-13
    - Added support for join(", ") function
    - Allows joining array of strings with a custom separator

0.30  2025-04-12
    - Enhanced META information for CPAN Testers and MetaCPAN
    - Added MIN_PERL_VERSION and no_index to Makefile.PL
    - Included bugtracker and repository links

0.29  2025-04-12
    - Added count function to return the number of items in the result set
    - Example: .users | count  → returns array length
              .users[] | select(...) | count → counts matching items
    - Adjusted count logic to treat both arrays and flat result lists properly
    - Added test: t/count.t

0.28  2025-04-12
    - Added group_by(...) function to group arrays by a field
    - Example: .users | group_by(department)
    - Added test: t/group_by.t

0.27  2025-04-12
    - Added support for pipe-style queries using .[] (e.g. .[] | select(...) | .name)
    - Introduced 'flatten' as internal command for .[] handling
    - Improved run_query parsing to better support chained queries with select()
    - Added test: t/pipe_select_name.t

0.26  2025-04-06
    - Improved interactive mode: input prompt is now always displayed at the bottom of the screen
      to avoid being overwritten by JSON output. This improves readability and usability when working
      with large or deeply nested JSON files.

0.25  2025-04-07
    - Added support for aggregation functions:
        * add   - sum of numeric arrays
        * min   - minimum value of numeric arrays
        * max   - maximum value of numeric arrays
        * avg   - average of numeric arrays
    - Improved CLI argument parsing:
        * Queries no longer require a leading dot (e.g. 'map(...)' now works)
        * File arguments are more accurately distinguished from query strings
        * Interactive mode works even without a query when only a JSON file is provided
    - Confirmed compatibility of map(), select(), and arithmetic expressions across CLI and interactive modes
    - All previous features and test cases remain working and fully compatible

0.24  2025-04-06
    - Added support for numeric expressions inside select(), e.g.:
        select(.id + 5 > 20)
    - Enhanced run_query() to evaluate simple arithmetic operations (+, -, *, /, %) in filters
    - Improved CLI query parsing to allow function-style queries like:
        map(select(.id > 10))
      without requiring a leading dot ('.')
    - Verified compatibility with map(), length, sort, and select chaining
    - Added test cases for arithmetic expressions and map/select combinations

0.23  2025-04-06
    - Added support for `map(...)` query syntax.
      Allows jq-style mapping and filtering of arrays, e.g.:
        map(select(.id > 10))
        map(.name)
    - Improved CLI (jq-lite) to accept function-style queries like map(...)
    - Fixed command-line argument parsing to handle non-dot-prefixed queries
    - Added tests for map(select(...)) to verify behavior

0.22  2025-04-06
    - Added test files:
        t/contains.t
        t/first_last.t
        t/friends.t
        t/has.t
        t/limit.t
        t/match_i.t
        t/match.t
        t/reverse.t
        t/sort_unique.t

0.21  2025-04-06
    - Prefer JSON::MaybeXS as the default decoder if available
    - Added support for user-specified decoder module selection including JSON::MaybeXS
    - Updated internal decoder selection logic with fallback to Cpanel::JSON::XS, JSON::XS, and JSON::PP

0.20  2025-04-06
    - Improved POD documentation: Added full CLI and API usage, supported syntax, and examples.
    - Added support for reverse, sort, first, last, unique, and has functions.
    - Added --use and --debug options to jq-lite CLI.
    - Added interactive mode to CLI when no query is provided.
    - Internal refactoring for modular query processing.

0.19  2025-04-06
    - Added support for faster JSON decoding by conditionally using Cpanel::JSON::XS or JSON::XS.
      Falls back to JSON::PP when XS modules are not available.
    - Added --debug option to show which JSON module is being used.
    - Added --use <ModuleName> option to explicitly select JSON parser (e.g. --use JSON::PP).
    - Improved CLI behavior and internal flexibility.

0.18  2025-04-06
    - Moved CLI script from script/jq-lite to bin/jq-lite for MetaCPAN visibility
    - Updated Makefile.PL to include EXE_FILES => ['bin/jq-lite']

0.17  2025-04-05
    - Added --color option to jq-lite CLI script to enable colorized JSON output.
      Keys are cyan, strings green, numbers yellow, and booleans/null magenta.
    - Updated help and usage examples to reflect the new --color option.
    - Improved CLI usability by simplifying option name (from --color-output to --color).

0.16  2025-04-05
    - Added --version (-v) option to the jq-lite CLI script.
      It displays the installed version of JQ::Lite.

0.14  2025-04-05
    - Fixed: --raw-output (-r) now pretty-prints objects and arrays,
             and outputs scalars as plain text, matching jq behavior.
    - Improved: Output formatting now distinguishes between scalars and structures.
    - Updated: Interactive mode preserves output consistency with command-line usage.

0.13  2025-04-05
    - Added real-time interactive mode: users can now type queries character-by-character
      and see results update immediately without pressing Enter.
    - Retains previous valid results on incomplete or invalid query input.
    - Displays full JSON on startup in interactive mode using '.' as default query.
    - Automatically enters interactive mode when reading JSON from STDIN without a query.
    - No non-core modules required: implemented raw terminal mode using 'stty'.

0.12 2025-04-05
    [Enhancement]
    - Added fallback behavior to show help message when jq-lite is executed with no arguments.
      This prevents the script from hanging waiting on STDIN and improves user experience.

0.11  2025-04-05
    - Added interactive mode to jq-lite command-line tool
      * Launches when no query is given
      * Accepts queries from /dev/tty
      * Clears screen before printing each result
      * Supports --raw-output (-r) in interactive mode
    - Improved argument parsing to allow: jq-lite users.json
    - Enhanced usability and documentation in README.md
0.10  2025-03-30
    - Added match operator for regular expressions (e.g. match "Bob")

0.09  2025-03-30
    - Added support for case-insensitive match (e.g. match "bob"i)
    - Added limit(n) operator to restrict number of results

0.08  2025-03-29
    - Added 'has' operator: select(.meta has "key")
    - Added 'first' and 'last' operators for arrays
    - Added 'reverse' operator to reverse array order
    - JQ-compatible enhancements for improved filtering and data navigation

0.07  2025-03-29
    - Removed use of eval in _evaluate_condition for better performance and stability.
    - Refactored _traverse for readability and maintainability.
    - Added support for multi-level array traversal (e.g., .users[].friends[].name).

































