dependabot-hex 0.118.13 → 0.119.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15b9133b51ceb0643d5be3bf66f1ef9c13c4d108692c2caee8004ff325ae65ef
-  data.tar.gz: 56d1e51a741756ec873cce6d8b4c8e2f55e45bbcdc7a4e917e865d712be4c57f
+  metadata.gz: 3604a148074d38433c48025d48dbc44da12cd64132cfd55372445b47dd830864
+  data.tar.gz: db60087432ed4e23f7edc0014348bb47175ca81fa5cdd1b1811936c747c0f260
 SHA512:
-  metadata.gz: 1d0aa7e6a6710d668a63e1f70aae63e0614e862ceaf285c8848f35c34d7542c3681a38b675d42dc7f199e602532d49fd10b1dbc9ac74053f3e9f4b5a91139aa9
-  data.tar.gz: 03e049e53a668a29a8a680f9d8ddbd67f31bc74b1aa0b95ca397307fb122ce78a7fa6429bf796ee130588e1c27bca7f04f29ced069aae98ff0ce70a6cf960156
+  metadata.gz: 4cc9b3bafe4314ea6147a566e4c99ba1f5ef9d53d8428fa50cf0bdd70736dc996b7c3e16d4e7c5869224504632d850ebe69f85fa4037a4b961633d9b8a2b5f4d
+  data.tar.gz: 549c1b9f72347c16f9bfbde5137e1ddf92a163283f0c016ea331867efa41e0ec64a4669074a6c4fd872235063b8621958b68980c3d7686a0d7ca68a8e4b7fa2c

data/helpers/install-dir/hex/deps/jason/CHANGELOG.md

@@ -0,0 +1,88 @@
+# Changelog
+
+## 1.2.1 (04.05.2020)
+
+### Security
+
+* Fix `html_safe` escaping in `Jason.encode`
+
+The `<!--` sequence of characters would not be escaped in `Jason.encode`
+with`html_escape` mode, which could lead to DoS attacks when used for
+embedding of arbitrary, user controlled strings into HTML through JSON
+(e.g. inside of `<script>` tags).
+
+If you were not using the `html_safe` option, you are not affected.
+
+Affected versions: < 1.2.1
+Patched versions: >= 1.2.1
+
+## 1.2.0 (17.03.2020)
+
+### Enhancements
+
+* Add `Jason.Encode.keyword/2`
+  ([cb1f26a](https://github.com/michalmuskala/jason/commit/cb1f26a)).
+
+### Bug fixes
+
+* Fix `Jason.Helpers.json_map/1` value expansion
+  ([70b046a](https://github.com/michalmuskala/jason/commit/70b046a)).
+
+## 1.1.2 (19.10.2018)
+
+### Bug fixes
+
+* correctly handle the `pretty: false` option
+  ([ba318c8](https://github.com/michalmuskala/jason/commit/ba318c8)).
+
+## 1.1.1 (10.07.2018)
+
+### Bug fixes
+
+* correctly handle escape sequences in strings when pretty printing
+  ([794bbe4](https://github.com/michalmuskala/jason/commit/794bbe4)).
+
+## 1.1.0 (02.07.2018)
+
+### Enhancements
+
+* pretty-printing support through `Jason.Formatter` and `pretty: true` option
+  in `Jason.encode/2` ([d758e36](https://github.com/michalmuskala/jason/commit/d758e36)).
+
+### Bug fixes
+
+* silence variable warnings for fields with underscores used during deriving
+  ([88dd85c](https://github.com/michalmuskala/jason/commit/88dd85c)).
+* **potential incompatibility** don't raise `Protocol.UndefinedError` in non-bang functions
+  ([ad0f57b](https://github.com/michalmuskala/jason/commit/ad0f57b)).
+
+## 1.0.1 (02.07.2018)
+
+### Bug fixes
+
+* fix `Jason.Encode.escape` type ([a57b430](https://github.com/michalmuskala/jason/commit/a57b430))
+* multiple documentation improvements
+
+## 1.0.0 (26.01.2018)
+
+No changes
+
+## 1.0.0-rc.3 (26.01.2018)
+
+### Changes
+
+* update `escape` option of `Jason.encode/2` to take values:
+  `:json | :unicode_safe | :html_safe | :javascript_safe` for consistency. Old values of
+  `:unicode` and `:javascript` are still supported for compatibility with Poison.
+  ([f42dcbd](https://github.com/michalmuskala/jason/commit/f42dcbd))
+
+## 1.0.0-rc.2 (07.01.2018)
+
+### Bug fixes
+
+* add type for `strings` option ([b459ee4](https://github.com/michalmuskala/jason/commit/b459ee4))
+* support iodata in `decode!` ([a1f3456](https://github.com/michalmuskala/jason/commit/a1f3456))
+
+## 1.0.0-rc.1 (22.12.2017)
+
+Initial release

data/helpers/install-dir/hex/deps/jason/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2017 Michał Muskała
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/helpers/install-dir/hex/deps/jason/README.md

@@ -0,0 +1,141 @@
+# Jason
+
+A blazing fast JSON parser and generator in pure Elixir.
+
+The parser and generator are at least twice as fast as other Elixir/Erlang libraries
+(most notably `Poison`).
+The performance is comparable to `jiffy`, which is implemented in C as a NIF.
+Jason is usually only twice as slow.
+
+Both parser and generator fully conform to
+[RFC 8259](https://tools.ietf.org/html/rfc8259) and
+[ECMA 404](http://www.ecma-international.org/publications/standards/Ecma-404.htm)
+standards. The parser is tested using [JSONTestSuite](https://github.com/nst/JSONTestSuite).
+
+## Installation
+
+The package can be installed by adding `jason` to your list of dependencies
+in `mix.exs`:
+
+```elixir
+def deps do
+  [{:jason, "~> 1.2"}]
+end
+```
+
+## Basic Usage
+
+``` elixir
+iex(1)> Jason.encode!(%{"age" => 44, "name" => "Steve Irwin", "nationality" => "Australian"})
+"{\"age\":44,\"name\":\"Steve Irwin\",\"nationality\":\"Australian\"}"
+
+iex(2)> Jason.decode!(~s({"age":44,"name":"Steve Irwin","nationality":"Australian"}))
+%{"age" => 44, "name" => "Steve Irwin", "nationality" => "Australian"}
+```
+
+Full documentation can be found at [https://hexdocs.pm/jason](https://hexdocs.pm/jason).
+
+## Use with other libraries
+
+### Postgrex
+
+Versions starting at 0.14.0 use `Jason` by default. For earlier versions, please refer to
+[previous versions of this document](https://github.com/michalmuskala/jason/tree/v1.1.2#postgrex).
+
+### Ecto
+
+Versions starting at 3.0.0 use `Jason` by default. For earlier versions, please refer to
+[previous versions of this document](https://github.com/michalmuskala/jason/tree/v1.1.2#ecto).
+
+### Plug (and Phoenix)
+
+Phoenix starting at 1.4.0 uses `Jason` by default. For earlier versions, please refer to
+[previous versions of this document](https://github.com/michalmuskala/jason/tree/v1.1.2#plug-and-phoenix).
+
+### Absinthe
+
+You need to pass the `:json_codec` option to `Absinthe.Plug`
+
+```elixir
+# When called directly:
+plug Absinthe.Plug,
+  schema: MyApp.Schema,
+  json_codec: Jason
+
+# When used in phoenix router:
+forward "/api",
+  to: Absinthe.Plug,
+  init_opts: [schema: MyApp.Schema, json_codec: Jason]
+```
+
+## Benchmarks
+
+Detailed benchmarks (including memory measurements):
+https://gist.github.com/michalmuskala/4d64a5a7696ca84ac7c169a0206640d5
+
+HTML reports for the benchmark (only performance measurements):
+http://michal.muskala.eu/jason/decode.html and http://michal.muskala.eu/jason/encode.html
+
+### Running
+
+Benchmarks against most popular Elixir & Erlang json libraries can be executed after
+going into the `bench/` folder and then executing `mix bench.encode` and `mix bench.decode`.
+A HTML report of the benchmarks (after their execution) can be found in
+`bench/output/encode.html` and `bench/output/decode.html` respectively.
+
+## Differences to Poison
+
+Jason has a couple feature differences compared to Poison.
+
+  * Jason follows the JSON spec more strictly, for example it does not allow
+    unescaped newline characters in JSON strings - e.g. `"\"\n\""` will
+    produce a decoding error.
+  * no support for decoding into data structures (the `as:` option).
+  * no built-in encoders for `MapSet`, `Range` and `Stream`.
+  * no support for encoding arbitrary structs - explicit implementation
+    of the `Jason.Encoder` protocol is always required.
+  * different pretty-printing customisation options (default `pretty: true` works the same)
+
+If you require encoders for any of the unsupported collection types, I suggest
+adding the needed implementations directly to your project:
+
+```elixir
+defimpl Jason.Encoder, for: [MapSet, Range, Stream] do
+  def encode(struct, opts) do
+    Jason.Encode.list(Enum.to_list(struct), opts)
+  end
+end
+```
+
+If you need to encode some struct that does not implement the protocol,
+if you own the struct, you can derive the implementation specifying
+which fields should be encoded to JSON:
+
+```elixir
+@derive {Jason.Encoder, only: [....]}
+defstruct # ...
+```
+
+It is also possible to encode all fields, although this should be
+used carefully to avoid accidentally leaking private information
+when new fields are added:
+
+```elixir
+@derive Jason.Encoder
+defstruct # ...
+```
+
+Finally, if you don't own the struct you want to encode to JSON,
+you may use `Protocol.derive/3` placed outside of any module:
+
+```elixir
+Protocol.derive(Jason.Encoder, NameOfTheStruct, only: [...])
+Protocol.derive(Jason.Encoder, NameOfTheStruct)
+```
+
+## License
+
+Jason is released under the Apache License 2.0 - see the [LICENSE](LICENSE) file.
+
+Some elements of tests and benchmarks have their origins in the
+[Poison library](https://github.com/devinus/poison) and were initially licensed under [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).

data/helpers/install-dir/hex/deps/jason/hex_metadata.config

@@ -0,0 +1,20 @@
+{<<"app">>,<<"jason">>}.
+{<<"build_tools">>,[<<"mix">>]}.
+{<<"description">>,
+ <<"A blazing fast JSON parser and generator in pure Elixir.">>}.
+{<<"elixir">>,<<"~> 1.4">>}.
+{<<"files">>,
+ [<<"lib">>,<<"lib/jason.ex">>,<<"lib/encoder.ex">>,<<"lib/decoder.ex">>,
+  <<"lib/formatter.ex">>,<<"lib/encode.ex">>,<<"lib/codegen.ex">>,
+  <<"lib/helpers.ex">>,<<"lib/fragment.ex">>,<<"mix.exs">>,<<"README.md">>,
+  <<"LICENSE">>,<<"CHANGELOG.md">>]}.
+{<<"licenses">>,[<<"Apache-2.0">>]}.
+{<<"links">>,[{<<"GitHub">>,<<"https://github.com/michalmuskala/jason">>}]}.
+{<<"name">>,<<"jason">>}.
+{<<"requirements">>,
+ [[{<<"app">>,<<"decimal">>},
+   {<<"name">>,<<"decimal">>},
+   {<<"optional">>,true},
+   {<<"repository">>,<<"hexpm">>},
+   {<<"requirement">>,<<"~> 1.0">>}]]}.
+{<<"version">>,<<"1.2.1">>}.

data/helpers/install-dir/hex/deps/jason/lib/codegen.ex

@@ -0,0 +1,138 @@
+defmodule Jason.Codegen do
+  @moduledoc false
+
+  alias Jason.{Encode, EncodeError}
+
+  def jump_table(ranges, default) do
+    ranges
+    |> ranges_to_orddict()
+    |> :array.from_orddict(default)
+    |> :array.to_orddict()
+  end
+
+  def jump_table(ranges, default, max) do
+    ranges
+    |> ranges_to_orddict()
+    |> :array.from_orddict(default)
+    |> resize(max)
+    |> :array.to_orddict()
+  end
+
+  defmacro bytecase(var, do: clauses) do
+    {ranges, default, literals} = clauses_to_ranges(clauses, [])
+
+    jump_table = jump_table(ranges, default)
+
+    quote do
+      case unquote(var) do
+        unquote(jump_table_to_clauses(jump_table, literals))
+      end
+    end
+  end
+
+  defmacro bytecase(var, max, do: clauses) do
+    {ranges, default, empty} = clauses_to_ranges(clauses, [])
+
+    jump_table = jump_table(ranges, default, max)
+
+    quote do
+      case unquote(var) do
+        unquote(jump_table_to_clauses(jump_table, empty))
+      end
+    end
+  end
+
+  def build_kv_iodata(kv, encode_args) do
+    elements =
+      kv
+      |> Enum.map(&encode_pair(&1, encode_args))
+      |> Enum.intersperse(",")
+
+    collapse_static(List.flatten(["{", elements] ++ '}'))
+  end
+
+  defp clauses_to_ranges([{:->, _, [[{:in, _, [byte, range]}, rest], action]} | tail], acc) do
+    clauses_to_ranges(tail, [{range, {byte, rest, action}} | acc])
+  end
+
+  defp clauses_to_ranges([{:->, _, [[default, rest], action]} | tail], acc) do
+    {Enum.reverse(acc), {default, rest, action}, literal_clauses(tail)}
+  end
+
+  defp literal_clauses(clauses) do
+    Enum.map(clauses, fn {:->, _, [[literal], action]} ->
+      {literal, action}
+    end)
+  end
+
+  defp jump_table_to_clauses([{val, {{:_, _, _}, rest, action}} | tail], empty) do
+    quote do
+      <<unquote(val), unquote(rest)::bits>> ->
+        unquote(action)
+    end ++ jump_table_to_clauses(tail, empty)
+  end
+
+  defp jump_table_to_clauses([{val, {byte, rest, action}} | tail], empty) do
+    quote do
+      <<unquote(byte), unquote(rest)::bits>> when unquote(byte) === unquote(val) ->
+        unquote(action)
+    end ++ jump_table_to_clauses(tail, empty)
+  end
+
+  defp jump_table_to_clauses([], literals) do
+    Enum.flat_map(literals, fn {pattern, action} ->
+      quote do
+        unquote(pattern) ->
+          unquote(action)
+      end
+    end)
+  end
+
+  defp resize(array, size), do: :array.resize(size, array)
+
+  defp ranges_to_orddict(ranges) do
+    ranges
+    |> Enum.flat_map(fn
+         {int, value} when is_integer(int) ->
+           [{int, value}]
+
+         {enum, value} ->
+           Enum.map(enum, &{&1, value})
+       end)
+    |> :orddict.from_list()
+  end
+
+  defp encode_pair({key, value}, encode_args) do
+    key = IO.iodata_to_binary(Encode.key(key, &escape_key/3))
+    key = "\"" <> key <> "\":"
+    [key, quote(do: Encode.value(unquote(value), unquote_splicing(encode_args)))]
+  end
+
+  defp escape_key(binary, _original, _skip) do
+    check_safe_key!(binary)
+    binary
+  end
+
+  defp check_safe_key!(binary) do
+    for <<(<<byte>> <- binary)>> do
+      if byte > 0x7F or byte < 0x1F or byte in '"\\/' do
+        raise EncodeError,
+              "invalid byte #{inspect(byte, base: :hex)} in literal key: #{inspect(binary)}"
+      end
+    end
+
+    :ok
+  end
+
+  defp collapse_static([bin1, bin2 | rest]) when is_binary(bin1) and is_binary(bin2) do
+    collapse_static([bin1 <> bin2 | rest])
+  end
+
+  defp collapse_static([other | rest]) do
+    [other | collapse_static(rest)]
+  end
+
+  defp collapse_static([]) do
+    []
+  end
+end

data/helpers/install-dir/hex/deps/jason/lib/decoder.ex

@@ -0,0 +1,657 @@
+defmodule Jason.DecodeError do
+  @type t :: %__MODULE__{position: integer, data: String.t}
+
+  defexception [:position, :token, :data]
+
+  def message(%{position: position, token: token}) when is_binary(token) do
+    "unexpected sequence at position #{position}: #{inspect token}"
+  end
+  def message(%{position: position, data: data}) when position == byte_size(data) do
+    "unexpected end of input at position #{position}"
+  end
+  def message(%{position: position, data: data}) do
+    byte = :binary.at(data, position)
+    str = <<byte>>
+    if String.printable?(str) do
+      "unexpected byte at position #{position}: " <>
+        "#{inspect byte, base: :hex} ('#{str}')"
+    else
+      "unexpected byte at position #{position}: " <>
+        "#{inspect byte, base: :hex}"
+    end
+  end
+end
+
+defmodule Jason.Decoder do
+  @moduledoc false
+
+  import Bitwise
+
+  alias Jason.{DecodeError, Codegen}
+
+  import Codegen, only: [bytecase: 2, bytecase: 3]
+
+  # @compile :native
+
+  # We use integers instead of atoms to take advantage of the jump table
+  # optimization
+  @terminate 0
+  @array     1
+  @key       2
+  @object    3
+
+  def parse(data, opts) when is_binary(data) do
+    key_decode = key_decode_function(opts)
+    string_decode = string_decode_function(opts)
+    try do
+      value(data, data, 0, [@terminate], key_decode, string_decode)
+    catch
+      {:position, position} ->
+        {:error, %DecodeError{position: position, data: data}}
+      {:token, token, position} ->
+        {:error, %DecodeError{token: token, position: position, data: data}}
+    else
+      value ->
+        {:ok, value}
+    end
+  end
+
+  defp key_decode_function(%{keys: :atoms}), do: &String.to_atom/1
+  defp key_decode_function(%{keys: :atoms!}), do: &String.to_existing_atom/1
+  defp key_decode_function(%{keys: :strings}), do: &(&1)
+  defp key_decode_function(%{keys: fun}) when is_function(fun, 1), do: fun
+
+  defp string_decode_function(%{strings: :copy}), do: &:binary.copy/1
+  defp string_decode_function(%{strings: :reference}), do: &(&1)
+
+  defp value(data, original, skip, stack, key_decode, string_decode) do
+    bytecase data do
+      _ in '\s\n\t\r', rest ->
+        value(rest, original, skip + 1, stack, key_decode, string_decode)
+      _ in '0', rest ->
+        number_zero(rest, original, skip, stack, key_decode, string_decode, 1)
+      _ in '123456789', rest ->
+        number(rest, original, skip, stack, key_decode, string_decode, 1)
+      _ in '-', rest ->
+        number_minus(rest, original, skip, stack, key_decode, string_decode)
+      _ in '"', rest ->
+        string(rest, original, skip + 1, stack, key_decode, string_decode, 0)
+      _ in '[', rest ->
+        array(rest, original, skip + 1, stack, key_decode, string_decode)
+      _ in '{', rest ->
+        object(rest, original, skip + 1, stack, key_decode, string_decode)
+      _ in ']', rest ->
+        empty_array(rest, original, skip + 1, stack, key_decode, string_decode)
+      _ in 't', rest ->
+        case rest do
+          <<"rue", rest::bits>> ->
+            continue(rest, original, skip + 4, stack, key_decode, string_decode, true)
+          <<_::bits>> ->
+            error(original, skip)
+        end
+      _ in 'f', rest ->
+        case rest do
+          <<"alse", rest::bits>> ->
+            continue(rest, original, skip + 5, stack, key_decode, string_decode, false)
+          <<_::bits>> ->
+            error(original, skip)
+        end
+      _ in 'n', rest ->
+        case rest do
+          <<"ull", rest::bits>> ->
+            continue(rest, original, skip + 4, stack, key_decode, string_decode, nil)
+          <<_::bits>> ->
+            error(original, skip)
+        end
+      _, rest ->
+        error(rest, original, skip + 1, stack, key_decode, string_decode)
+      <<_::bits>> ->
+        error(original, skip)
+    end
+  end
+
+  defp number_minus(<<?0, rest::bits>>, original, skip, stack, key_decode, string_decode) do
+    number_zero(rest, original, skip, stack, key_decode, string_decode, 2)
+  end
+  defp number_minus(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode)
+       when byte in '123456789' do
+    number(rest, original, skip, stack, key_decode, string_decode, 2)
+  end
+  defp number_minus(<<_rest::bits>>, original, skip, _stack, _key_decode, _string_decode) do
+    error(original, skip + 1)
+  end
+
+  defp number(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, len)
+       when byte in '0123456789' do
+    number(rest, original, skip, stack, key_decode, string_decode, len + 1)
+  end
+  defp number(<<?., rest::bits>>, original, skip, stack, key_decode, string_decode, len) do
+    number_frac(rest, original, skip, stack, key_decode, string_decode, len + 1)
+  end
+  defp number(<<e, rest::bits>>, original, skip, stack, key_decode, string_decode, len) when e in 'eE' do
+    prefix = binary_part(original, skip, len)
+    number_exp_copy(rest, original, skip + len + 1, stack, key_decode, string_decode, prefix)
+  end
+  defp number(<<rest::bits>>, original, skip, stack, key_decode, string_decode, len) do
+    int = String.to_integer(binary_part(original, skip, len))
+    continue(rest, original, skip + len, stack, key_decode, string_decode, int)
+  end
+
+  defp number_frac(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, len)
+       when byte in '0123456789' do
+    number_frac_cont(rest, original, skip, stack, key_decode, string_decode, len + 1)
+  end
+  defp number_frac(<<_rest::bits>>, original, skip, _stack, _key_decode, _string_decode, len) do
+    error(original, skip + len)
+  end
+
+  defp number_frac_cont(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, len)
+       when byte in '0123456789' do
+    number_frac_cont(rest, original, skip, stack, key_decode, string_decode, len + 1)
+  end
+  defp number_frac_cont(<<e, rest::bits>>, original, skip, stack, key_decode, string_decode, len)
+       when e in 'eE' do
+    number_exp(rest, original, skip, stack, key_decode, string_decode, len + 1)
+  end
+  defp number_frac_cont(<<rest::bits>>, original, skip, stack, key_decode, string_decode, len) do
+    token = binary_part(original, skip, len)
+    float = try_parse_float(token, token, skip)
+    continue(rest, original, skip + len, stack, key_decode, string_decode, float)
+  end
+
+  defp number_exp(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, len)
+       when byte in '0123456789' do
+    number_exp_cont(rest, original, skip, stack, key_decode, string_decode, len + 1)
+  end
+  defp number_exp(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, len)
+       when byte in '+-' do
+    number_exp_sign(rest, original, skip, stack, key_decode, string_decode, len + 1)
+  end
+  defp number_exp(<<_rest::bits>>, original, skip, _stack, _key_decode, _string_decode, len) do
+    error(original, skip + len)
+  end
+
+  defp number_exp_sign(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, len)
+       when byte in '0123456789' do
+    number_exp_cont(rest, original, skip, stack, key_decode, string_decode, len + 1)
+  end
+  defp number_exp_sign(<<_rest::bits>>, original, skip, _stack, _key_decode, _string_decode, len) do
+    error(original, skip + len)
+  end
+
+  defp number_exp_cont(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, len)
+       when byte in '0123456789' do
+    number_exp_cont(rest, original, skip, stack, key_decode, string_decode, len + 1)
+  end
+  defp number_exp_cont(<<rest::bits>>, original, skip, stack, key_decode, string_decode, len) do
+    token = binary_part(original, skip, len)
+    float = try_parse_float(token, token, skip)
+    continue(rest, original, skip + len, stack, key_decode, string_decode, float)
+  end
+
+  defp number_exp_copy(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, prefix)
+       when byte in '0123456789' do
+    number_exp_cont(rest, original, skip, stack, key_decode, string_decode, prefix, 1)
+  end
+  defp number_exp_copy(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, prefix)
+       when byte in '+-' do
+    number_exp_sign(rest, original, skip, stack, key_decode, string_decode, prefix, 1)
+  end
+  defp number_exp_copy(<<_rest::bits>>, original, skip, _stack, _key_decode, _string_decode, _prefix) do
+    error(original, skip)
+  end
+
+  defp number_exp_sign(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, prefix, len)
+       when byte in '0123456789' do
+    number_exp_cont(rest, original, skip, stack, key_decode, string_decode, prefix, len + 1)
+  end
+  defp number_exp_sign(<<_rest::bits>>, original, skip, _stack, _key_decode, _string_decode, _prefix, len) do
+    error(original, skip + len)
+  end
+
+  defp number_exp_cont(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, prefix, len)
+       when byte in '0123456789' do
+    number_exp_cont(rest, original, skip, stack, key_decode, string_decode, prefix, len + 1)
+  end
+  defp number_exp_cont(<<rest::bits>>, original, skip, stack, key_decode, string_decode, prefix, len) do
+    suffix = binary_part(original, skip, len)
+    string = prefix <> ".0e" <> suffix
+    prefix_size = byte_size(prefix)
+    initial_skip = skip - prefix_size - 1
+    final_skip = skip + len
+    token = binary_part(original, initial_skip, prefix_size + len + 1)
+    float = try_parse_float(string, token, initial_skip)
+    continue(rest, original, final_skip, stack, key_decode, string_decode, float)
+  end
+
+  defp number_zero(<<?., rest::bits>>, original, skip, stack, key_decode, string_decode, len) do
+    number_frac(rest, original, skip, stack, key_decode, string_decode, len + 1)
+  end
+  defp number_zero(<<e, rest::bits>>, original, skip, stack, key_decode, string_decode, len) when e in 'eE' do
+    number_exp_copy(rest, original, skip + len + 1, stack, key_decode, string_decode, "0")
+  end
+  defp number_zero(<<rest::bits>>, original, skip, stack, key_decode, string_decode, len) do
+    continue(rest, original, skip + len, stack, key_decode, string_decode, 0)
+  end
+
+  @compile {:inline, array: 6}
+
+  defp array(rest, original, skip, stack, key_decode, string_decode) do
+    value(rest, original, skip, [@array, [] | stack], key_decode, string_decode)
+  end
+
+  defp empty_array(<<rest::bits>>, original, skip, stack, key_decode, string_decode) do
+    case stack do
+      [@array, [] | stack] ->
+        continue(rest, original, skip, stack, key_decode, string_decode, [])
+      _ ->
+        error(original, skip - 1)
+    end
+  end
+
+  defp array(data, original, skip, stack, key_decode, string_decode, value) do
+    bytecase data do
+      _ in '\s\n\t\r', rest ->
+        array(rest, original, skip + 1, stack, key_decode, string_decode, value)
+      _ in ']', rest ->
+        [acc | stack] = stack
+        value = :lists.reverse(acc, [value])
+        continue(rest, original, skip + 1, stack, key_decode, string_decode, value)
+      _ in ',', rest ->
+        [acc | stack] = stack
+        value(rest, original, skip + 1, [@array, [value | acc] | stack], key_decode, string_decode)
+      _, _rest ->
+        error(original, skip)
+      <<_::bits>> ->
+        empty_error(original, skip)
+    end
+  end
+
+  @compile {:inline, object: 6}
+
+  defp object(rest, original, skip, stack, key_decode, string_decode) do
+    key(rest, original, skip, [[] | stack], key_decode, string_decode)
+  end
+
+  defp object(data, original, skip, stack, key_decode, string_decode, value) do
+    bytecase data do
+      _ in '\s\n\t\r', rest ->
+        object(rest, original, skip + 1, stack, key_decode, string_decode, value)
+      _ in '}', rest ->
+        skip = skip + 1
+        [key, acc | stack] = stack
+        final = [{key_decode.(key), value} | acc]
+        continue(rest, original, skip, stack, key_decode, string_decode, :maps.from_list(final))
+      _ in ',', rest ->
+        skip = skip + 1
+        [key, acc | stack] = stack
+        acc = [{key_decode.(key), value} | acc]
+        key(rest, original, skip, [acc | stack], key_decode, string_decode)
+      _, _rest ->
+        error(original, skip)
+      <<_::bits>> ->
+        empty_error(original, skip)
+    end
+  end
+
+  defp key(data, original, skip, stack, key_decode, string_decode) do
+    bytecase data do
+      _ in '\s\n\t\r', rest ->
+        key(rest, original, skip + 1, stack, key_decode, string_decode)
+      _ in '}', rest ->
+        case stack do
+          [[] | stack] ->
+            continue(rest, original, skip + 1, stack, key_decode, string_decode, %{})
+          _ ->
+            error(original, skip)
+        end
+      _ in '"', rest ->
+        string(rest, original, skip + 1, [@key | stack], key_decode, string_decode, 0)
+      _, _rest ->
+        error(original, skip)
+      <<_::bits>> ->
+        empty_error(original, skip)
+    end
+  end
+
+  defp key(data, original, skip, stack, key_decode, string_decode, value) do
+    bytecase data do
+      _ in '\s\n\t\r', rest ->
+        key(rest, original, skip + 1, stack, key_decode, string_decode, value)
+      _ in ':', rest ->
+        value(rest, original, skip + 1, [@object, value | stack], key_decode, string_decode)
+      _, _rest ->
+        error(original, skip)
+      <<_::bits>> ->
+        empty_error(original, skip)
+    end
+  end
+
+  # TODO: check if this approach would be faster:
+  # https://git.ninenines.eu/cowlib.git/tree/src/cow_ws.erl#n469
+  # http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+  defp string(data, original, skip, stack, key_decode, string_decode, len) do
+    bytecase data, 128 do
+      _ in '"', rest ->
+        string = string_decode.(binary_part(original, skip, len))
+        continue(rest, original, skip + len + 1, stack, key_decode, string_decode, string)
+      _ in '\\', rest ->
+        part = binary_part(original, skip, len)
+        escape(rest, original, skip + len, stack, key_decode, string_decode, part)
+      _ in unquote(0x00..0x1F), _rest ->
+        error(original, skip)
+      _, rest ->
+        string(rest, original, skip, stack, key_decode, string_decode, len + 1)
+      <<char::utf8, rest::bits>> when char <= 0x7FF ->
+        string(rest, original, skip, stack, key_decode, string_decode, len + 2)
+      <<char::utf8, rest::bits>> when char <= 0xFFFF ->
+        string(rest, original, skip, stack, key_decode, string_decode, len + 3)
+      <<_char::utf8, rest::bits>> ->
+        string(rest, original, skip, stack, key_decode, string_decode, len + 4)
+      <<_::bits>> ->
+        empty_error(original, skip + len)
+    end
+  end
+
+  defp string(data, original, skip, stack, key_decode, string_decode, acc, len) do
+    bytecase data, 128 do
+      _ in '"', rest ->
+        last = binary_part(original, skip, len)
+        string = IO.iodata_to_binary([acc | last])
+        continue(rest, original, skip + len + 1, stack, key_decode, string_decode, string)
+      _ in '\\', rest ->
+        part = binary_part(original, skip, len)
+        escape(rest, original, skip + len, stack, key_decode, string_decode, [acc | part])
+      _ in unquote(0x00..0x1F), _rest ->
+        error(original, skip)
+      _, rest ->
+        string(rest, original, skip, stack, key_decode, string_decode, acc, len + 1)
+      <<char::utf8, rest::bits>> when char <= 0x7FF ->
+        string(rest, original, skip, stack, key_decode, string_decode, acc, len + 2)
+      <<char::utf8, rest::bits>> when char <= 0xFFFF ->
+        string(rest, original, skip, stack, key_decode, string_decode, acc, len + 3)
+      <<_char::utf8, rest::bits>> ->
+        string(rest, original, skip, stack, key_decode, string_decode, acc, len + 4)
+      <<_::bits>> ->
+        empty_error(original, skip + len)
+    end
+  end
+
+  defp escape(data, original, skip, stack, key_decode, string_decode, acc) do
+    bytecase data do
+      _ in 'b', rest ->
+        string(rest, original, skip + 2, stack, key_decode, string_decode, [acc | '\b'], 0)
+      _ in 't', rest ->
+        string(rest, original, skip + 2, stack, key_decode, string_decode, [acc | '\t'], 0)
+      _ in 'n', rest ->
+        string(rest, original, skip + 2, stack, key_decode, string_decode, [acc | '\n'], 0)
+      _ in 'f', rest ->
+        string(rest, original, skip + 2, stack, key_decode, string_decode, [acc | '\f'], 0)
+      _ in 'r', rest ->
+        string(rest, original, skip + 2, stack, key_decode, string_decode, [acc | '\r'], 0)
+      _ in '"', rest ->
+        string(rest, original, skip + 2, stack, key_decode, string_decode, [acc | '\"'], 0)
+      _ in '/', rest ->
+        string(rest, original, skip + 2, stack, key_decode, string_decode, [acc | '/'], 0)
+      _ in '\\', rest ->
+        string(rest, original, skip + 2, stack, key_decode, string_decode, [acc | '\\'], 0)
+      _ in 'u', rest ->
+        escapeu(rest, original, skip, stack, key_decode, string_decode, acc)
+      _, _rest ->
+        error(original, skip + 1)
+      <<_::bits>> ->
+        empty_error(original, skip)
+    end
+  end
+
+  defmodule Unescape do
+    @moduledoc false
+
+    import Bitwise
+
+    @digits Enum.concat([?0..?9, ?A..?F, ?a..?f])
+
+    def unicode_escapes(chars1 \\ @digits, chars2 \\ @digits) do
+      for char1 <- chars1, char2 <- chars2 do
+        {(char1 <<< 8) + char2, integer8(char1, char2)}
+      end
+    end
+
+    defp integer8(char1, char2) do
+      (integer4(char1) <<< 4) + integer4(char2)
+    end
+
+    defp integer4(char) when char in ?0..?9, do: char - ?0
+    defp integer4(char) when char in ?A..?F, do: char - ?A + 10
+    defp integer4(char) when char in ?a..?f, do: char - ?a + 10
+
+    defp token_error_clause(original, skip, len) do
+      quote do
+        _ ->
+          token_error(unquote_splicing([original, skip, len]))
+      end
+    end
+
+    defmacro escapeu_first(int, last, rest, original, skip, stack, key_decode, string_decode, acc) do
+      clauses = escapeu_first_clauses(last, rest, original, skip, stack, key_decode, string_decode, acc)
+      quote location: :keep do
+        case unquote(int) do
+          unquote(clauses ++ token_error_clause(original, skip, 6))
+        end
+      end
+    end
+
+    defp escapeu_first_clauses(last, rest, original, skip, stack, key_decode, string_decode, acc) do
+      for {int, first} <- unicode_escapes(),
+          not (first in 0xDC..0xDF) do
+        escapeu_first_clause(int, first, last, rest, original, skip, stack, key_decode, string_decode, acc)
+      end
+    end
+
+    defp escapeu_first_clause(int, first, last, rest, original, skip, stack, key_decode, string_decode, acc)
+         when first in 0xD8..0xDB do
+      hi =
+        quote bind_quoted: [first: first, last: last] do
+          0x10000 + ((((first &&& 0x03) <<< 8) + last) <<< 10)
+        end
+      args = [rest, original, skip, stack, key_decode, string_decode, acc, hi]
+      [clause] =
+        quote location: :keep do
+          unquote(int) -> escape_surrogate(unquote_splicing(args))
+        end
+      clause
+    end
+
+    defp escapeu_first_clause(int, first, last, rest, original, skip, stack, key_decode, string_decode, acc)
+         when first <= 0x00 do
+      skip = quote do: (unquote(skip) + 6)
+      acc =
+        quote bind_quoted: [acc: acc, first: first, last: last] do
+          if last <= 0x7F do
+            # 0?????
+            [acc, last]
+          else
+            # 110xxxx??  10?????
+            byte1 = ((0b110 <<< 5) + (first <<< 2)) + (last >>> 6)
+            byte2 = (0b10 <<< 6) + (last &&& 0b111111)
+            [acc, byte1, byte2]
+          end
+        end
+      args = [rest, original, skip, stack, key_decode, string_decode, acc, 0]
+      [clause] =
+        quote location: :keep do
+          unquote(int) -> string(unquote_splicing(args))
+        end
+      clause
+    end
+
+    defp escapeu_first_clause(int, first, last, rest, original, skip, stack, key_decode, string_decode, acc)
+         when first <= 0x07 do
+      skip = quote do: (unquote(skip) + 6)
+      acc =
+        quote bind_quoted: [acc: acc, first: first, last: last] do
+          # 110xxx??  10??????
+          byte1 = ((0b110 <<< 5) + (first <<< 2)) + (last >>> 6)
+          byte2 = (0b10 <<< 6) + (last &&& 0b111111)
+          [acc, byte1, byte2]
+        end
+      args = [rest, original, skip, stack, key_decode, string_decode, acc, 0]
+      [clause] =
+        quote location: :keep do
+          unquote(int) -> string(unquote_splicing(args))
+        end
+      clause
+    end
+
+    defp escapeu_first_clause(int, first, last, rest, original, skip, stack, key_decode, string_decode, acc)
+         when first <= 0xFF do
+      skip = quote do: (unquote(skip) + 6)
+      acc =
+        quote bind_quoted: [acc: acc, first: first, last: last] do
+          # 1110xxxx  10xxxx??  10??????
+          byte1 = (0b1110 <<< 4) + (first >>> 4)
+          byte2 = ((0b10 <<< 6) + ((first &&& 0b1111) <<< 2)) + (last >>> 6)
+          byte3 = (0b10 <<< 6) + (last &&& 0b111111)
+          [acc, byte1, byte2, byte3]
+        end
+      args = [rest, original, skip, stack, key_decode, string_decode, acc, 0]
+      [clause] =
+        quote location: :keep do
+          unquote(int) -> string(unquote_splicing(args))
+        end
+      clause
+    end
+
+    defmacro escapeu_last(int, original, skip) do
+      clauses = escapeu_last_clauses()
+      quote location: :keep do
+        case unquote(int) do
+          unquote(clauses ++ token_error_clause(original, skip, 6))
+        end
+      end
+    end
+
+    defp escapeu_last_clauses() do
+      for {int, last} <- unicode_escapes() do
+        [clause] =
+          quote do
+            unquote(int) -> unquote(last)
+          end
+        clause
+      end
+    end
+
+    defmacro escapeu_surrogate(int, last, rest, original, skip, stack, key_decode, string_decode, acc,
+             hi) do
+      clauses = escapeu_surrogate_clauses(last, rest, original, skip, stack, key_decode, string_decode, acc, hi)
+      quote location: :keep do
+        case unquote(int) do
+          unquote(clauses ++ token_error_clause(original, skip, 12))
+        end
+      end
+    end
+
+    defp escapeu_surrogate_clauses(last, rest, original, skip, stack, key_decode, string_decode, acc, hi) do
+      digits1 = 'Dd'
+      digits2 = Stream.concat([?C..?F, ?c..?f])
+      for {int, first} <- unicode_escapes(digits1, digits2) do
+        escapeu_surrogate_clause(int, first, last, rest, original, skip, stack, key_decode, string_decode, acc, hi)
+      end
+    end
+
+    defp escapeu_surrogate_clause(int, first, last, rest, original, skip, stack, key_decode, string_decode, acc, hi) do
+      skip = quote do: unquote(skip) + 12
+      acc =
+        quote bind_quoted: [acc: acc, first: first, last: last, hi: hi] do
+          lo = ((first &&& 0x03) <<< 8) + last
+          [acc | <<(hi + lo)::utf8>>]
+        end
+      args = [rest, original, skip, stack, key_decode, string_decode, acc, 0]
+      [clause] =
+        quote do
+          unquote(int) ->
+            string(unquote_splicing(args))
+        end
+      clause
+    end
+  end
+
+  defp escapeu(<<int1::16, int2::16, rest::bits>>, original, skip, stack, key_decode, string_decode, acc) do
+    require Unescape
+    last = escapeu_last(int2, original, skip)
+    Unescape.escapeu_first(int1, last, rest, original, skip, stack, key_decode, string_decode, acc)
+  end
+  defp escapeu(<<_rest::bits>>, original, skip, _stack, _key_decode, _string_decode, _acc) do
+    empty_error(original, skip)
+  end
+
+  # @compile {:inline, escapeu_last: 3}
+
+  defp escapeu_last(int, original, skip) do
+    require Unescape
+    Unescape.escapeu_last(int, original, skip)
+  end
+
+  defp escape_surrogate(<<?\\, ?u, int1::16, int2::16, rest::bits>>, original,
+       skip, stack, key_decode, string_decode, acc, hi) do
+    require Unescape
+    last = escapeu_last(int2, original, skip + 6)
+    Unescape.escapeu_surrogate(int1, last, rest, original, skip, stack, key_decode, string_decode, acc, hi)
+  end
+  defp escape_surrogate(<<_rest::bits>>, original, skip, _stack, _key_decode, _string_decode, _acc, _hi) do
+    error(original, skip + 6)
+  end
+
+  defp try_parse_float(string, token, skip) do
+    :erlang.binary_to_float(string)
+  catch
+    :error, :badarg ->
+      token_error(token, skip)
+  end
+
+  defp error(<<_rest::bits>>, _original, skip, _stack, _key_decode, _string_decode) do
+    throw {:position, skip - 1}
+  end
+
+  defp empty_error(_original, skip) do
+    throw {:position, skip}
+  end
+
+  @compile {:inline, error: 2, token_error: 2, token_error: 3}
+  defp error(_original, skip) do
+    throw {:position, skip}
+  end
+
+  defp token_error(token, position) do
+    throw {:token, token, position}
+  end
+
+  defp token_error(token, position, len) do
+    throw {:token, binary_part(token, position, len), position}
+  end
+
+  @compile {:inline, continue: 7}
+  defp continue(rest, original, skip, stack, key_decode, string_decode, value) do
+    case stack do
+      [@terminate | stack] ->
+        terminate(rest, original, skip, stack, key_decode, string_decode, value)
+      [@array | stack] ->
+        array(rest, original, skip, stack, key_decode, string_decode, value)
+      [@key | stack] ->
+        key(rest, original, skip, stack, key_decode, string_decode, value)
+      [@object | stack] ->
+        object(rest, original, skip, stack, key_decode, string_decode, value)
+    end
+  end
+
+  defp terminate(<<byte, rest::bits>>, original, skip, stack, key_decode, string_decode, value)
+       when byte in '\s\n\r\t' do
+    terminate(rest, original, skip + 1, stack, key_decode, string_decode, value)
+  end
+  defp terminate(<<>>, _original, _skip, _stack, _key_decode, _string_decode, value) do
+    value
+  end
+  defp terminate(<<_rest::bits>>, original, skip, _stack, _key_decode, _string_decode, _value) do
+    error(original, skip)
+  end
+end