[package]
name = "serde_partiql"
version = "1.1.65"
description = "A PartiQL data model serialization file format"
keywords = ["serde", "serialization"]
categories = ["encoding"]
readme = "README.md"
include = [
	"build.rs",
	"src/**/*.rs",
	"README.md",
	"LICENSE-APACHE",
	"LICENSE-MIT",
]
edition = "2018"
license = "MIT"

[dependencies]
serde = { version = "1.0.100", default-features = false }
indexmap = { version = "1.5", optional = true }
itoa = { version = "0.4.3", default-features = false }
ryu = "1.0"

[dev-dependencies]
automod = "1.0"
rustversion = "1.0"
serde_bytes = "0.11"
serde_derive = "1.0"
serde_stacker = "0.1"
trybuild = { version = "1.0.19", features = ["diff"] }

[workspace]
members = ["tests/crate"]

[package.metadata.docs.rs]
features = ["raw_value", "unbounded_depth"]
targets = ["x86_64-unknown-linux-gnu"]

[package.metadata.playground]
features = ["raw_value"]


### FEATURES #################################################################

[features]
default = ["std"]

std = ["serde/std"]

# Provide integration for heap-allocated collections without depending on the
# rest of the Rust standard library.
# NOTE: Disabling both `std` *and* `alloc` features is not supported yet.
# Available on Rust 1.36+.
alloc = ["serde/alloc"]

# Make serde_partiql::Map use a representation which maintains insertion order.
# This allows data to be read into a Value and written back to a JSON string
# while preserving the order of map keys in the input.
preserve_order = ["indexmap"]

# Use sufficient precision when parsing fixed precision floats from JSON to
# ensure that they maintain accuracy when round-tripped through JSON. This comes
# at an approximately 2x performance cost for parsing floats compared to the
# default best-effort precision.
#
# Unlike arbitrary_precision, this feature makes f64 -> JSON -> f64 produce
# output identical to the input.
float_roundtrip = []

# Use an arbitrary precision number representation for serde_partiql::Number. This
# allows JSON numbers of arbitrary size/precision to be read into a Number and
# written back to a JSON string without loss of precision.
#
# Unlike float_roundtrip, this feature makes JSON -> serde_partiql::Number -> JSON
# produce output identical to the input.
arbitrary_precision = []

# Provide a RawValue type that can hold unprocessed JSON during deserialization.
raw_value = []

# Provide a method disable_recursion_limit to parse arbitrarily deep JSON
# structures without any consideration for overflowing the stack. When using
# this feature, you will want to provide some other way to protect against stack
# overflows, such as by wrapping your Deserializer in the dynamically growing
# stack adapter provided by the serde_stacker crate. Additionally you will need
# to be careful around other recursive operations on the parsed result which may
# overflow the stack after deserialization has completed, including, but not
# limited to, Display and Debug and Drop impls.
unbounded_depth = []