json.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2021-08-30 21:44+0800\n"
"Last-Translator: Juan Pablo Esparza R. <jesparzarom@outlook.com>\n"
"Language: es_ES\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.13.0\n"

#: ../Doc/library/json.rst:2
msgid ":mod:`json` --- JSON encoder and decoder"
msgstr ":mod:`json` --- Codificador y decodificador JSON"

#: ../Doc/library/json.rst:10
msgid "**Source code:** :source:`Lib/json/__init__.py`"
msgstr "**Código fuente:** :source:`Lib/json/__init__.py`"

#: ../Doc/library/json.rst:14
msgid ""
"`JSON (JavaScript Object Notation) <https://json.org>`_, specified by :rfc:"
"`7159` (which obsoletes :rfc:`4627`) and by `ECMA-404 <https://www.ecma-"
"international.org/publications-and-standards/standards/ecma-404/>`_, is a "
"lightweight data interchange format inspired by `JavaScript <https://en."
"wikipedia.org/wiki/JavaScript>`_ object literal syntax (although it is not a "
"strict subset of JavaScript [#rfc-errata]_ )."
msgstr ""
"`JSON (JavaScript Object Notation) <https://json.org>`_, especificado por :"
"rfc:`7159` (que hace obsoleto a :rfc:`4627`) y por `ECMA-404 <https://www."
"ecma-international.org/publications-and-standards/standards/ecma-404/>`_, es "
"un formato de intercambio de datos ligero inspirado en la sintaxis literal "
"del objeto `JavaScript <https://en.wikipedia.org/wiki/JavaScript>`_ (aunque "
"no es un subconjunto estricto de JavaScript [#rfc-errata]_ )."

#: ../Doc/library/json.rst:22
msgid ""
"Be cautious when parsing JSON data from untrusted sources. A malicious JSON "
"string may cause the decoder to consume considerable CPU and memory "
"resources. Limiting the size of data to be parsed is recommended."
msgstr ""
"Se debe tener cuidado al analizar datos JSON de fuentes que no son de "
"confianza. Una cadena JSON maliciosa puede hacer que el decodificador "
"consuma considerables recursos del CPU y la memoria. Se recomienda limitar "
"el tamaño de los datos que se van a analizar."

#: ../Doc/library/json.rst:26
msgid ""
":mod:`json` exposes an API familiar to users of the standard library :mod:"
"`marshal` and :mod:`pickle` modules."
msgstr ""
":mod:`json` expone una API familiar a los usuarios de los módulos de la "
"biblioteca estándar :mod:`marshal` y :mod:`pickle`."

#: ../Doc/library/json.rst:29
msgid "Encoding basic Python object hierarchies::"
msgstr "Codificación de jerarquías básicas de objetos de Python::"

#: ../Doc/library/json.rst:48
msgid "Compact encoding::"
msgstr "Codificación compacta::"

#: ../Doc/library/json.rst:54
msgid "Pretty printing::"
msgstr "Impresión linda::"

#: ../Doc/library/json.rst:63
msgid "Decoding JSON::"
msgstr "Decodificación JSON::"

#: ../Doc/library/json.rst:75
msgid "Specializing JSON object decoding::"
msgstr "Decodificación personalizada de objetos JSON::"

#: ../Doc/library/json.rst:90
msgid "Extending :class:`JSONEncoder`::"
msgstr "Extendiendo :class:`JSONEncoder`::"

#: ../Doc/library/json.rst:108
msgid "Using :mod:`json.tool` from the shell to validate and pretty-print:"
msgstr ""
"Usando :mod:`json.tool` desde el shell para validación e impresión con "
"sangría:"

#: ../Doc/library/json.rst:119
msgid "See :ref:`json-commandline` for detailed documentation."
msgstr "Consulte :ref:`json-commandline` para obtener documentación detallada."

#: ../Doc/library/json.rst:123
msgid ""
"JSON is a subset of `YAML <https://yaml.org/>`_ 1.2.  The JSON produced by "
"this module's default settings (in particular, the default *separators* "
"value) is also a subset of YAML 1.0 and 1.1.  This module can thus also be "
"used as a YAML serializer."
msgstr ""
"JSON es un subconjunto de `YAML <http://yaml.org/>`_ 1.2. El JSON producido "
"por la configuración predeterminada de este módulo (en particular, el valor "
"predeterminado *separators*) también es un subconjunto de YAML 1.0 y 1.1. "
"Por lo tanto, este módulo también se puede utilizar como un serializador "
"YAML."

#: ../Doc/library/json.rst:130
msgid ""
"This module's encoders and decoders preserve input and output order by "
"default.  Order is only lost if the underlying containers are unordered."
msgstr ""
"Los codificadores y decodificadores de este módulo conservan el orden de "
"entrada y salida de forma predeterminada. El orden solo se pierde si los "
"contenedores subyacentes no están ordenados."

#: ../Doc/library/json.rst:135
msgid "Basic Usage"
msgstr "Uso básico"

#: ../Doc/library/json.rst:142
msgid ""
"Serialize *obj* as a JSON formatted stream to *fp* (a ``.write()``-"
"supporting :term:`file-like object`) using this :ref:`conversion table <py-"
"to-json-table>`."
msgstr ""
"Serializa *obj* como una secuencia con formato JSON a *fp* (una invocación  "
"``.write()``- que soporta :term:`file-like object`) usando esto :ref:"
"`conversion table <py-to-json-table>`."

#: ../Doc/library/json.rst:146
msgid ""
"If *skipkeys* is true (default: ``False``), then dict keys that are not of a "
"basic type (:class:`str`, :class:`int`, :class:`float`, :class:`bool`, "
"``None``) will be skipped instead of raising a :exc:`TypeError`."
msgstr ""
"Si *skipkeys* es verdadero (predeterminado: ``False``), entonces las llaves "
"del dict que no son de un tipo básico (:class:`str`, :class:`int`, :class:"
"`float`, :class:`bool`, ``None``) se omitirán en lugar de generar un :exc:"
"`TypeError`."

#: ../Doc/library/json.rst:150
msgid ""
"The :mod:`json` module always produces :class:`str` objects, not :class:"
"`bytes` objects. Therefore, ``fp.write()`` must support :class:`str` input."
msgstr ""
"El módulo :mod:`json` siempre produce objetos :class:`str`, no objetos :"
"class:`bytes`. Por lo tanto, ``fp.write()`` debe admitir :class:`str` como "
"entrada."

#: ../Doc/library/json.rst:154 ../Doc/library/json.rst:433
msgid ""
"If *ensure_ascii* is true (the default), the output is guaranteed to have "
"all incoming non-ASCII characters escaped.  If *ensure_ascii* is false, "
"these characters will be output as-is."
msgstr ""
"Si *ensure_ascii* es verdadero (el valor predeterminado), se garantiza que "
"la salida tendrá todos los caracteres entrantes no ASCII escapados. Si "
"*ensure_ascii* es falso, estos caracteres se mostrarán tal cual."

#: ../Doc/library/json.rst:158
msgid ""
"If *check_circular* is false (default: ``True``), then the circular "
"reference check for container types will be skipped and a circular reference "
"will result in a :exc:`RecursionError` (or worse)."
msgstr ""
"Si *check_circular* es falso (predeterminado: ``True``), se omitirá la "
"verificación de referencia circular para los tipos de contenedor y una "
"referencia circular dará como resultado :exc:`RecursionError` (o algo peor)."

#: ../Doc/library/json.rst:162
msgid ""
"If *allow_nan* is false (default: ``True``), then it will be a :exc:"
"`ValueError` to serialize out of range :class:`float` values (``nan``, "
"``inf``, ``-inf``) in strict compliance of the JSON specification. If "
"*allow_nan* is true, their JavaScript equivalents (``NaN``, ``Infinity``, ``-"
"Infinity``) will be used."
msgstr ""
"Si *allow_nan* es falso (predeterminado: ``True``), entonces serializar los "
"valores fuera de rango :class:`float` (``nan``, ``inf``, ``-inf``) provocará "
"un :exc:`ValueError` en estricto cumplimiento de la especificación JSON. Si "
"*allow_nan* es verdadero, se utilizarán sus equivalentes de JavaScript "
"(``NaN``, ``Infinity``, ``-Infinity``)."

#: ../Doc/library/json.rst:168 ../Doc/library/json.rst:452
msgid ""
"If *indent* is a non-negative integer or string, then JSON array elements "
"and object members will be pretty-printed with that indent level.  An indent "
"level of 0, negative, or ``\"\"`` will only insert newlines.  ``None`` (the "
"default) selects the most compact representation. Using a positive integer "
"indent indents that many spaces per level.  If *indent* is a string (such as "
"``\"\\t\"``), that string is used to indent each level."
msgstr ""
"Si *indent* es un entero no negativo o una cadena, los elementos del arreglo "
"JSON y los miembros del objeto se imprimirán con ese nivel de sangría. Un "
"nivel de sangría de 0, negativo o ``\"\"`` solo insertará nuevas líneas. "
"``None`` (el valor predeterminado) selecciona la representación más "
"compacta. El uso de una sangría de entero positivo agrega sangrías de muchos "
"espacios por nivel. Si *indent* es una cadena (como ``\"\\t\"``), esa cadena "
"se usa para agregarle sangría a cada nivel."

#: ../Doc/library/json.rst:175 ../Doc/library/json.rst:459
msgid "Allow strings for *indent* in addition to integers."
msgstr "Permite cadenas  de caracteres para *indent* además de enteros."

#: ../Doc/library/json.rst:178 ../Doc/library/json.rst:462
msgid ""
"If specified, *separators* should be an ``(item_separator, key_separator)`` "
"tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and ``(',', "
"': ')`` otherwise.  To get the most compact JSON representation, you should "
"specify ``(',', ':')`` to eliminate whitespace."
msgstr ""
"Si se especifica, *separators* debe ser una tupla ``(separador_elemento, "
"separador_llave)``. El valor predeterminado es ``(', ', ': ')`` si *indent* "
"es ``None`` y ``(', ', ': ')`` de lo contrario. Para obtener la "
"representación JSON más compacta, debe especificar ``(', ', ': ')`` para "
"eliminar espacios en blanco."

#: ../Doc/library/json.rst:183 ../Doc/library/json.rst:467
msgid "Use ``(',', ': ')`` as default if *indent* is not ``None``."
msgstr "Usa ``(',', ': ')`` como predeterminado si *indent* no es ``None``."

#: ../Doc/library/json.rst:186 ../Doc/library/json.rst:470
msgid ""
"If specified, *default* should be a function that gets called for objects "
"that can't otherwise be serialized.  It should return a JSON encodable "
"version of the object or raise a :exc:`TypeError`.  If not specified, :exc:"
"`TypeError` is raised."
msgstr ""
"Si se especifica, *default* debería ser una función que se llama para "
"objetos que de otro modo no se pueden serializar. Debería retornar una "
"versión codificable JSON del objeto o generar un :exc:`TypeError`. Si no se "
"especifica, produce :exc:`TypeError`."

#: ../Doc/library/json.rst:191
msgid ""
"If *sort_keys* is true (default: ``False``), then the output of dictionaries "
"will be sorted by key."
msgstr ""
"Si *sort_keys* es verdadero (predeterminado: ``False``), la salida de los "
"diccionarios se ordenará por llave."

#: ../Doc/library/json.rst:194
#, fuzzy
msgid ""
"To use a custom :class:`JSONEncoder` subclass (e.g. one that overrides the :"
"meth:`~JSONEncoder.default` method to serialize additional types), specify "
"it with the *cls* kwarg; otherwise :class:`JSONEncoder` is used."
msgstr ""
"Para usar una subclase personalizada de :class:`JSONEncoder` (por ejemplo, "
"una que sobre escriba el método :meth:`default` para serializar tipos "
"adicionales), se especifica mediante el argumento por palabra clave *cls*; "
"de lo contrario se usa :class:`JSONEncoder`."

#: ../Doc/library/json.rst:198 ../Doc/library/json.rst:277
msgid ""
"All optional parameters are now :ref:`keyword-only <keyword-only_parameter>`."
msgstr ""
"Todos los parámetros opcionales son ahora :ref:`palabra-clave-solamente "
"<keyword-only_parameter>`."

#: ../Doc/library/json.rst:203
msgid ""
"Unlike :mod:`pickle` and :mod:`marshal`, JSON is not a framed protocol, so "
"trying to serialize multiple objects with repeated calls to :func:`dump` "
"using the same *fp* will result in an invalid JSON file."
msgstr ""
"A diferencia de :mod:`pickle` y :mod:`marshal`, JSON no es un protocolo "
"enmarcado, por lo que intentar serializar varios objetos con llamadas "
"repetidas a :func:`dump` utilizando el mismo *fp* dará como resultado un "
"archivo JSON no válido."

#: ../Doc/library/json.rst:212
msgid ""
"Serialize *obj* to a JSON formatted :class:`str` using this :ref:`conversion "
"table <py-to-json-table>`.  The arguments have the same meaning as in :func:"
"`dump`."
msgstr ""
"Serializa *obj* en un :class:`str` con formato JSON usando esta :ref:"
"`conversion table <py-to-json-table>`.  Los argumentos tienen el mismo "
"significado que en :func:`dump`."

#: ../Doc/library/json.rst:218
msgid ""
"Keys in key/value pairs of JSON are always of the type :class:`str`. When a "
"dictionary is converted into JSON, all the keys of the dictionary are "
"coerced to strings. As a result of this, if a dictionary is converted into "
"JSON and then back into a dictionary, the dictionary may not equal the "
"original one. That is, ``loads(dumps(x)) != x`` if x has non-string keys."
msgstr ""
"Las llaves de los pares llave/valor de JSON siempre son del tipo :class:"
"`str`. Cuando un diccionario se convierte en JSON, todas las llaves del "
"diccionario se convierten en cadenas. Como resultado de esto, si un "
"diccionario se convierte en JSON y, a continuación, se convierte nuevamente "
"en un diccionario, el diccionario puede que no sea igual al original. Es "
"decir, ``loads(dumps(x)) != x`` si x tiene llaves que no son de tipo cadena "
"de caracteres."

# un ``.read()``-compatible
#: ../Doc/library/json.rst:227
msgid ""
"Deserialize *fp* (a ``.read()``-supporting :term:`text file` or :term:"
"`binary file` containing a JSON document) to a Python object using this :ref:"
"`conversion table <json-to-py-table>`."
msgstr ""
"Deserializa *fp* (un :term:`text file` o :term:`binary file` que soporte ``."
"read()`` y que contiene un documento JSON) a un objeto Python usando esta :"
"ref:`conversion table <json-to-py-table>`."

#: ../Doc/library/json.rst:231
msgid ""
"*object_hook* is an optional function that will be called with the result of "
"any object literal decoded (a :class:`dict`).  The return value of "
"*object_hook* will be used instead of the :class:`dict`.  This feature can "
"be used to implement custom decoders (e.g. `JSON-RPC <https://www.jsonrpc."
"org>`_ class hinting)."
msgstr ""
"*object_hook* es una función opcional a la que se llamará con el resultado "
"de cualquier literal de objeto decodificado (un :class:`dict`).  El valor de "
"retorno de *object_hook* se utilizará en lugar de :class:`dict`. Esta "
"característica se puede utilizar para implementar decodificadores "
"personalizados (por ejemplo, la sugerencia de clase `JSON-RPC <http://www."
"jsonrpc.org>`_)."

#: ../Doc/library/json.rst:237
msgid ""
"*object_pairs_hook* is an optional function that will be called with the "
"result of any object literal decoded with an ordered list of pairs.  The "
"return value of *object_pairs_hook* will be used instead of the :class:"
"`dict`.  This feature can be used to implement custom decoders. If "
"*object_hook* is also defined, the *object_pairs_hook* takes priority."
msgstr ""
"*object_pairs_hook* es una función opcional a la que se llamará con el "
"resultado de cualquier literal de objeto decodificado con una lista ordenada "
"de pares.  El valor de retorno de *object_pairs_hook* se utilizará en lugar "
"de :class:`dict`.  Esta característica se puede utilizar para implementar "
"decodificadores personalizados. Si también se define *object_hook*, el "
"*object_pairs_hook* tiene prioridad."

#: ../Doc/library/json.rst:243 ../Doc/library/json.rst:348
msgid "Added support for *object_pairs_hook*."
msgstr "Soporte agregado para *object_pairs_hook*."

#: ../Doc/library/json.rst:246 ../Doc/library/json.rst:351
msgid ""
"*parse_float*, if specified, will be called with the string of every JSON "
"float to be decoded.  By default, this is equivalent to ``float(num_str)``. "
"This can be used to use another datatype or parser for JSON floats (e.g. :"
"class:`decimal.Decimal`)."
msgstr ""
"*parse_float*, si se especifica, se llamará con la cadena de cada flotante "
"JSON que se va a decodificar.  De forma predeterminada, esto es equivalente "
"a ``float(num_str)``. Esto se puede utilizar para hacer uso de otro tipo de "
"datos o analizador para flotantes JSON (por ejemplo :class:`decimal. "
"Decimal`)."

#: ../Doc/library/json.rst:251 ../Doc/library/json.rst:356
msgid ""
"*parse_int*, if specified, will be called with the string of every JSON int "
"to be decoded.  By default, this is equivalent to ``int(num_str)``.  This "
"can be used to use another datatype or parser for JSON integers (e.g. :class:"
"`float`)."
msgstr ""
"*parse_int*, si se especifica, se llamará con la cadena de cada entero JSON "
"que se va a decodificar.  De forma predeterminada, esto es equivalente a "
"``int(num_str)``.  Esto se puede utilizar para hace uso de otro tipo de "
"datos o analizador para enteros JSON (por ejemplo :class:`float`)."

#: ../Doc/library/json.rst:256
msgid ""
"The default *parse_int* of :func:`int` now limits the maximum length of the "
"integer string via the interpreter's :ref:`integer string conversion length "
"limitation <int_max_str_digits>` to help avoid denial of service attacks."
msgstr ""
"El *parse_int* predeterminado de :func:`int` ahora limita la longitud máxima "
"de la cadena de enteros a través de la :ref:`integer string conversion "
"length limitation <int_max_str_digits>` del intérprete para ayudar a evitar "
"ataques de denegación de servicio."

#: ../Doc/library/json.rst:262 ../Doc/library/json.rst:361
msgid ""
"*parse_constant*, if specified, will be called with one of the following "
"strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``. This can be used to "
"raise an exception if invalid JSON numbers are encountered."
msgstr ""
"*parse_constant*, si se especifica, se llamará con una de las siguientes "
"cadenas: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``. Esto se puede utilizar "
"para generar una excepción si se encuentran números JSON inválidos."

#: ../Doc/library/json.rst:267
msgid "*parse_constant* doesn't get called on 'null', 'true', 'false' anymore."
msgstr "*parse_constant* ya no es llamado en 'null', 'true', 'false'."

#: ../Doc/library/json.rst:270
msgid ""
"To use a custom :class:`JSONDecoder` subclass, specify it with the ``cls`` "
"kwarg; otherwise :class:`JSONDecoder` is used.  Additional keyword arguments "
"will be passed to the constructor of the class."
msgstr ""
"Para utilizar una subclase personalizada de :class:`JSONDecoder`, "
"especificarlo con el argumento por llave ``cls``; de lo contrario, se "
"utilizará :class:`JSONDecoder`.  Se pasarán argumentos adicionales de "
"palabra llave al constructor de la clase."

#: ../Doc/library/json.rst:274 ../Doc/library/json.rst:292
#: ../Doc/library/json.rst:371
msgid ""
"If the data being deserialized is not a valid JSON document, a :exc:"
"`JSONDecodeError` will be raised."
msgstr ""
"Si los datos que se deserializan no constituyen un documento JSON válido, se "
"lanzará un :exc:`JSONDecodeError`."

#: ../Doc/library/json.rst:280
msgid ""
"*fp* can now be a :term:`binary file`. The input encoding should be UTF-8, "
"UTF-16 or UTF-32."
msgstr ""
"*fp* ahora puede ser un :term:`binary file`. La codificación de entrada debe "
"ser UTF-8, UTF-16 o UTF-32."

#: ../Doc/library/json.rst:286
msgid ""
"Deserialize *s* (a :class:`str`, :class:`bytes` or :class:`bytearray` "
"instance containing a JSON document) to a Python object using this :ref:"
"`conversion table <json-to-py-table>`."
msgstr ""
"Deserializa *s* (una instancia :class:`str`, :class:`bytes` o :class:"
"`bytearray` que contiene un documento JSON) en un objeto Python mediante "
"esta :ref:`conversion table <json-to-py-table>`."

#: ../Doc/library/json.rst:290
msgid "The other arguments have the same meaning as in :func:`load`."
msgstr "Los otros argumentos tienen el mismo significado que en :func:`load`."

#: ../Doc/library/json.rst:295
msgid ""
"*s* can now be of type :class:`bytes` or :class:`bytearray`. The input "
"encoding should be UTF-8, UTF-16 or UTF-32."
msgstr ""
"*s* ahora puede ser de tipo :class:`bytes` o :class:`bytearray`. La "
"codificación de entrada debe ser UTF-8, UTF-16 o UTF-32."

#: ../Doc/library/json.rst:299
msgid "The keyword argument *encoding* has been removed."
msgstr "El argumento de palabra llave *encoding* ha sido removido."

#: ../Doc/library/json.rst:304
msgid "Encoders and Decoders"
msgstr "Codificadores y Decodificadores"

#: ../Doc/library/json.rst:308
msgid "Simple JSON decoder."
msgstr "Decodificador JSON simple."

#: ../Doc/library/json.rst:310
msgid "Performs the following translations in decoding by default:"
msgstr ""
"Realiza las siguientes traducciones en la decodificación de forma "
"predeterminada:"

#: ../Doc/library/json.rst:315 ../Doc/library/json.rst:404
msgid "JSON"
msgstr "JSON"

#: ../Doc/library/json.rst:315 ../Doc/library/json.rst:404
msgid "Python"
msgstr "Python"

#: ../Doc/library/json.rst:317 ../Doc/library/json.rst:406
msgid "object"
msgstr "object"

#: ../Doc/library/json.rst:317 ../Doc/library/json.rst:406
msgid "dict"
msgstr "dict"

#: ../Doc/library/json.rst:319 ../Doc/library/json.rst:408
msgid "array"
msgstr "array"

#: ../Doc/library/json.rst:319
msgid "list"
msgstr "list"

#: ../Doc/library/json.rst:321 ../Doc/library/json.rst:410
msgid "string"
msgstr "string"

#: ../Doc/library/json.rst:321 ../Doc/library/json.rst:410
msgid "str"
msgstr "str"

#: ../Doc/library/json.rst:323
msgid "number (int)"
msgstr "número (int)"

#: ../Doc/library/json.rst:323
msgid "int"
msgstr "int"

#: ../Doc/library/json.rst:325
msgid "number (real)"
msgstr "número (real)"

#: ../Doc/library/json.rst:325
msgid "float"
msgstr "float"

#: ../Doc/library/json.rst:327 ../Doc/library/json.rst:414
msgid "true"
msgstr "true"

#: ../Doc/library/json.rst:327 ../Doc/library/json.rst:414
msgid "True"
msgstr "True"

#: ../Doc/library/json.rst:329 ../Doc/library/json.rst:416
msgid "false"
msgstr "false"

#: ../Doc/library/json.rst:329 ../Doc/library/json.rst:416
msgid "False"
msgstr "False"

#: ../Doc/library/json.rst:331 ../Doc/library/json.rst:418
msgid "null"
msgstr "null"

#: ../Doc/library/json.rst:331 ../Doc/library/json.rst:418
msgid "None"
msgstr "None"

#: ../Doc/library/json.rst:334
msgid ""
"It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as their "
"corresponding ``float`` values, which is outside the JSON spec."
msgstr ""
"También entiende ``NaN``, ``Infinity`` y ``-Infinity`` como sus "
"correspondientes valores ``float``, que está fuera de la especificación JSON."

#: ../Doc/library/json.rst:337
msgid ""
"*object_hook*, if specified, will be called with the result of every JSON "
"object decoded and its return value will be used in place of the given :"
"class:`dict`.  This can be used to provide custom deserializations (e.g. to "
"support `JSON-RPC <https://www.jsonrpc.org>`_ class hinting)."
msgstr ""
"*object_hook*, si se especifica, se llamará con el resultado de cada objeto "
"JSON decodificado y su valor de retorno se utilizará en lugar de la :class:"
"`dict` dada.  Esto se puede usar para proporcionar deserializaciones "
"personalizadas (por ejemplo, para admitir sugerencias de clases `JSON-RPC "
"<http://www.jsonrpc.org>`_)."

#: ../Doc/library/json.rst:342
msgid ""
"*object_pairs_hook*, if specified will be called with the result of every "
"JSON object decoded with an ordered list of pairs.  The return value of "
"*object_pairs_hook* will be used instead of the :class:`dict`.  This feature "
"can be used to implement custom decoders.  If *object_hook* is also defined, "
"the *object_pairs_hook* takes priority."
msgstr ""
"*object_pairs_hook*, si se especifica se llamará con el resultado de cada "
"objeto JSON decodificado con una lista ordenada de pares.  El valor de "
"retorno de *object_pairs_hook* se utilizará en lugar de :class:`dict`.  Esta "
"característica se puede utilizar para implementar decodificadores "
"personalizados.  Si también se define *object_hook*, el *object_pairs_hook* "
"tiene prioridad."

#: ../Doc/library/json.rst:366
msgid ""
"If *strict* is false (``True`` is the default), then control characters will "
"be allowed inside strings.  Control characters in this context are those "
"with character codes in the 0--31 range, including ``'\\t'`` (tab), "
"``'\\n'``, ``'\\r'`` and ``'\\0'``."
msgstr ""
"Si *strict* es falso (''True'' es el valor predeterminado), se permitirán "
"caracteres de control dentro de cadenas.  Los caracteres de control en este "
"contexto son aquellos con códigos de caracteres en el rango 0--31, "
"incluyendo ``'\\t'`` (tab), ``'\\n'``, ``'\\r'`` and ``'\\0'``."

#: ../Doc/library/json.rst:374 ../Doc/library/json.rst:475
msgid "All parameters are now :ref:`keyword-only <keyword-only_parameter>`."
msgstr ""
"Todos los parámetros son ahora :ref:`palabra-clave-solamente <keyword-"
"only_parameter>`."

#: ../Doc/library/json.rst:379
msgid ""
"Return the Python representation of *s* (a :class:`str` instance containing "
"a JSON document)."
msgstr ""
"Retorna la representación Python de *s* (una instancia :class:`str` que "
"contiene un documento JSON)."

#: ../Doc/library/json.rst:382
msgid ""
":exc:`JSONDecodeError` will be raised if the given JSON document is not "
"valid."
msgstr ""
":exc:`JSONDecodeError` se producirá si el documento JSON entregado es "
"invalido."

#: ../Doc/library/json.rst:387
msgid ""
"Decode a JSON document from *s* (a :class:`str` beginning with a JSON "
"document) and return a 2-tuple of the Python representation and the index in "
"*s* where the document ended."
msgstr ""
"Decodifica un documento JSON de *s* (un :class:`str` comenzando con un "
"documento JSON) y retorna una tupla de 2 de la representación Python y el "
"índice en *s* donde terminó el documento."

#: ../Doc/library/json.rst:391
msgid ""
"This can be used to decode a JSON document from a string that may have "
"extraneous data at the end."
msgstr ""
"Esto se puede usar para decodificar un documento JSON de una cadena de "
"caracteres que puede tener datos extraños al final."

#: ../Doc/library/json.rst:397
msgid "Extensible JSON encoder for Python data structures."
msgstr "Codificador JSON extensible para estructuras de datos de Python."

#: ../Doc/library/json.rst:399
msgid "Supports the following objects and types by default:"
msgstr "Admite los siguientes objetos y tipos de forma predeterminada:"

#: ../Doc/library/json.rst:408
msgid "list, tuple"
msgstr "list, tuple"

#: ../Doc/library/json.rst:412
msgid "int, float, int- & float-derived Enums"
msgstr "int, float, Enums derivadas de int o float"

#: ../Doc/library/json.rst:412
msgid "number"
msgstr "number"

#: ../Doc/library/json.rst:421
msgid "Added support for int- and float-derived Enum classes."
msgstr "Compatibilidad añadida con las clases Enum derivadas de int y float."

#: ../Doc/library/json.rst:424
#, fuzzy
msgid ""
"To extend this to recognize other objects, subclass and implement a :meth:"
"`~JSONEncoder.default` method with another method that returns a "
"serializable object for ``o`` if possible, otherwise it should call the "
"superclass implementation (to raise :exc:`TypeError`)."
msgstr ""
"A fin de extender esto para reconocer otros objetos, implementar una "
"subclase con un método :meth:`default` con otro método que retorna un objeto "
"serializable para ''o'' si es posible, de lo contrario debe llamar a la "
"implementación de superclase (para lanzar :exc:`TypeError`)."

#: ../Doc/library/json.rst:429
msgid ""
"If *skipkeys* is false (the default), a :exc:`TypeError` will be raised when "
"trying to encode keys that are not :class:`str`, :class:`int`, :class:"
"`float` or ``None``.  If *skipkeys* is true, such items are simply skipped."
msgstr ""
"Si *skipkeys* es falso (lo es por defecto), un :exc:`TypeError` será lanzado "
"cuando se trate de codificar llaves que no sean :class:`str`, :class:`int`, :"
"class:`float` o ``None``.  Si *skipkeys* es verdadero, tales elementos son "
"simplemente pasados por alto."

#: ../Doc/library/json.rst:437
msgid ""
"If *check_circular* is true (the default), then lists, dicts, and custom "
"encoded objects will be checked for circular references during encoding to "
"prevent an infinite recursion (which would cause a :exc:`RecursionError`). "
"Otherwise, no such check takes place."
msgstr ""
"Si *check_circular* es cierto (valor predeterminado), se comprobarán las "
"listas, los diccionarios y los objetos codificados personalizados en busca "
"de referencias circulares durante la codificación para evitar una "
"recursividad infinita (lo que provocaría un :exc:`RecursionError`). De lo "
"contrario, no se realiza ninguna comprobación de este tipo."

#: ../Doc/library/json.rst:442
msgid ""
"If *allow_nan* is true (the default), then ``NaN``, ``Infinity``, and ``-"
"Infinity`` will be encoded as such.  This behavior is not JSON specification "
"compliant, but is consistent with most JavaScript based encoders and "
"decoders.  Otherwise, it will be a :exc:`ValueError` to encode such floats."
msgstr ""
"Si *allow_nan* es cierto (valor predeterminado), ``NaN``, ``Infinity`` y ``-"
"Infinity`` se codificarán como tales.  Este comportamiento no es compatible "
"con las especificaciones JSON, pero es coherente con la mayoría de los "
"codificadores y decodificadores basados en JavaScript.  De lo contrario, "
"codificar dichos puntos flotantes provocará un :exc:`ValueError`."

#: ../Doc/library/json.rst:448
msgid ""
"If *sort_keys* is true (default: ``False``), then the output of dictionaries "
"will be sorted by key; this is useful for regression tests to ensure that "
"JSON serializations can be compared on a day-to-day basis."
msgstr ""
"Si *sort_keys* es cierto (predeterminado: ``False``), la salida de los "
"diccionarios se ordenará por clave; esto es útil para las pruebas de "
"regresión para garantizar que las serializaciones JSON se pueden comparar en "
"el día a día."

#: ../Doc/library/json.rst:481
msgid ""
"Implement this method in a subclass such that it returns a serializable "
"object for *o*, or calls the base implementation (to raise a :exc:"
"`TypeError`)."
msgstr ""
"Implemente este método en una subclase de modo que retorne un objeto "
"serializable para *o*, o llame a la implementación base (para generar un :"
"exc:`TypeError`)."

#: ../Doc/library/json.rst:485
#, fuzzy
msgid ""
"For example, to support arbitrary iterators, you could implement :meth:"
"`~JSONEncoder.default` like this::"
msgstr ""
"Por ejemplo, para admitir iteradores arbitrarios, podría implementar :meth:"
"`default` de esta manera::"

#: ../Doc/library/json.rst:501
msgid ""
"Return a JSON string representation of a Python data structure, *o*.  For "
"example::"
msgstr ""
"Retorna una representación de cadena de caracteres JSON de una estructura de "
"datos de Python, *o*.  Por ejemplo::"

#: ../Doc/library/json.rst:510
msgid ""
"Encode the given object, *o*, and yield each string representation as "
"available.  For example::"
msgstr ""
"Codifica el objeto dado, *o*, y produce cada representación de cadena como "
"disponible.  Por ejemplo::"

#: ../Doc/library/json.rst:518
msgid "Exceptions"
msgstr "Excepciones"

#: ../Doc/library/json.rst:522
msgid "Subclass of :exc:`ValueError` with the following additional attributes:"
msgstr ""
"Subclase de :exc:`ValueError` con los siguientes atributos adicionales:"

#: ../Doc/library/json.rst:526
msgid "The unformatted error message."
msgstr "El mensaje de error sin formato."

#: ../Doc/library/json.rst:530
msgid "The JSON document being parsed."
msgstr "El documento JSON que se está analizando."

#: ../Doc/library/json.rst:534
msgid "The start index of *doc* where parsing failed."
msgstr "El índice de inicio de *doc* donde se produjo un error en el análisis."

#: ../Doc/library/json.rst:538
msgid "The line corresponding to *pos*."
msgstr "La línea correspondiente a *pos*."

#: ../Doc/library/json.rst:542
msgid "The column corresponding to *pos*."
msgstr "La columna correspondiente a *pos*."

#: ../Doc/library/json.rst:548
msgid "Standard Compliance and Interoperability"
msgstr "Cumplimiento e interoperabilidad estándar"

#: ../Doc/library/json.rst:550
msgid ""
"The JSON format is specified by :rfc:`7159` and by `ECMA-404 <https://www."
"ecma-international.org/publications-and-standards/standards/ecma-404/>`_. "
"This section details this module's level of compliance with the RFC. For "
"simplicity, :class:`JSONEncoder` and :class:`JSONDecoder` subclasses, and "
"parameters other than those explicitly mentioned, are not considered."
msgstr ""
"El formato JSON se especifica por :rfc:`7159` y por `ECMA-404 <https://www."
"ecma-international.org/publications-and-standards/standards/ecma-404/>`_. "
"Esta sección detalla el nivel de cumplimiento de la RFC de este módulo. Para "
"simplificar, :class:`JSONEncoder` y :class:`JSONDecoder` subclases, y los "
"parámetros distintos de los mencionados explícitamente, no se consideran."

#: ../Doc/library/json.rst:556
msgid ""
"This module does not comply with the RFC in a strict fashion, implementing "
"some extensions that are valid JavaScript but not valid JSON.  In particular:"
msgstr ""
"Este módulo no cumple con la RFC de forma estricta, implementando algunas "
"extensiones que son válidas  en JavaScript pero no son válidas en JSON.  En "
"particular:"

#: ../Doc/library/json.rst:559
msgid "Infinite and NaN number values are accepted and output;"
msgstr "Se aceptan y se envían valores de números Infinitos y NaN;"

#: ../Doc/library/json.rst:560
msgid ""
"Repeated names within an object are accepted, and only the value of the last "
"name-value pair is used."
msgstr ""
"Se aceptan nombres repetidos dentro de un objeto y solo se utiliza el valor "
"del último par nombre-valor."

#: ../Doc/library/json.rst:563
msgid ""
"Since the RFC permits RFC-compliant parsers to accept input texts that are "
"not RFC-compliant, this module's deserializer is technically RFC-compliant "
"under default settings."
msgstr ""
"Puesto que el RFC permite a los analizadores compatibles con RFC aceptar "
"textos de entrada que no son compatibles con RFC, el deserializador de este "
"módulo es técnicamente compatible con RFC bajo la configuración "
"predeterminada."

#: ../Doc/library/json.rst:568
msgid "Character Encodings"
msgstr "Codificaciones de caracteres"

#: ../Doc/library/json.rst:570
msgid ""
"The RFC requires that JSON be represented using either UTF-8, UTF-16, or "
"UTF-32, with UTF-8 being the recommended default for maximum "
"interoperability."
msgstr ""
"La RFC requiere que JSON se represente mediante UTF-8, UTF-16 o UTF-32, "
"siendo UTF-8 el valor predeterminado recomendado para la máxima "
"interoperabilidad."

#: ../Doc/library/json.rst:573
msgid ""
"As permitted, though not required, by the RFC, this module's serializer sets "
"*ensure_ascii=True* by default, thus escaping the output so that the "
"resulting strings only contain ASCII characters."
msgstr ""
"Según lo permitido, aunque no es necesario, por la RFC, el serializador de "
"este módulo establece *ensure_ascii=True* de forma predeterminada, escapando "
"así el dato de salida para que las cadenas resultantes solo contengan "
"caracteres ASCII."

#: ../Doc/library/json.rst:577
msgid ""
"Other than the *ensure_ascii* parameter, this module is defined strictly in "
"terms of conversion between Python objects and :class:`Unicode strings "
"<str>`, and thus does not otherwise directly address the issue of character "
"encodings."
msgstr ""
"Aparte del parámetro *ensure_ascii*, este módulo se define estrictamente en "
"términos de conversión entre objetos Python y :class:`Unicode strings "
"<str>`, y por lo tanto no aborda directamente el problema de las "
"codificaciones de caracteres."

#: ../Doc/library/json.rst:582
msgid ""
"The RFC prohibits adding a byte order mark (BOM) to the start of a JSON "
"text, and this module's serializer does not add a BOM to its output. The RFC "
"permits, but does not require, JSON deserializers to ignore an initial BOM "
"in their input.  This module's deserializer raises a :exc:`ValueError` when "
"an initial BOM is present."
msgstr ""
"La RFC prohíbe agregar una marca de orden byte (BOM, por sus siglas en "
"inglés) al inicio de un texto JSON y el serializador de este módulo no "
"agrega una BOM a su salida. La RFC permite, pero no requiere, "
"deserializadores JSON para omitir una BOM inicial en su entrada.  El "
"deserializador de este módulo genera un :exc:`ValueError` cuando hay una "
"lista de materiales inicial."

#: ../Doc/library/json.rst:588
msgid ""
"The RFC does not explicitly forbid JSON strings which contain byte sequences "
"that don't correspond to valid Unicode characters (e.g. unpaired UTF-16 "
"surrogates), but it does note that they may cause interoperability problems. "
"By default, this module accepts and outputs (when present in the original :"
"class:`str`) code points for such sequences."
msgstr ""
"La RFC no prohíbe explícitamente las cadenas JSON que contienen secuencias "
"de bytes que no corresponden a caracteres Unicode válidos (por ejemplo, "
"sustitutos UTF-16 no espaciados), pero sí tiene en cuenta que pueden causar "
"problemas de interoperabilidad. De forma predeterminada, este módulo acepta "
"y genera puntos de código (cuando está presente en el original :class:`str`) "
"para dichas secuencias."

#: ../Doc/library/json.rst:596
msgid "Infinite and NaN Number Values"
msgstr "Valores de número infinito y NaN"

#: ../Doc/library/json.rst:598
msgid ""
"The RFC does not permit the representation of infinite or NaN number values. "
"Despite that, by default, this module accepts and outputs ``Infinity``, ``-"
"Infinity``, and ``NaN`` as if they were valid JSON number literal values::"
msgstr ""
"El RFC no permite la representación de los valores de número infinito o NaN. "
"A pesar de eso, de forma predeterminada, este módulo acepta y genera "
"``Infinity``, ``-Infinity`` y ``NaN`` como si fueran valores literales de "
"número JSON válidos::"

#: ../Doc/library/json.rst:613
msgid ""
"In the serializer, the *allow_nan* parameter can be used to alter this "
"behavior.  In the deserializer, the *parse_constant* parameter can be used "
"to alter this behavior."
msgstr ""
"En el serializador, el parámetro *allow_nan* se puede utilizar para "
"modificar este comportamiento.  En el deserializador, se puede utilizar el "
"parámetro *parse_constant* para modificar este comportamiento."

#: ../Doc/library/json.rst:619
msgid "Repeated Names Within an Object"
msgstr "Nombres repetidos dentro de un objeto"

#: ../Doc/library/json.rst:621
msgid ""
"The RFC specifies that the names within a JSON object should be unique, but "
"does not mandate how repeated names in JSON objects should be handled.  By "
"default, this module does not raise an exception; instead, it ignores all "
"but the last name-value pair for a given name::"
msgstr ""
"La RFC especifica que los nombres dentro de un objeto JSON deben ser únicos, "
"pero no exige cómo se deben controlar los nombres repetidos en los objetos "
"JSON.  De forma predeterminada, este módulo no genera una excepción; en su "
"lugar, ignora todo excepto el último par nombre-valor para un nombre dado::"

#: ../Doc/library/json.rst:630
msgid "The *object_pairs_hook* parameter can be used to alter this behavior."
msgstr ""
"El parámetro *object_pairs_hook* se puede utilizar para alterar este "
"comportamiento."

#: ../Doc/library/json.rst:634
msgid "Top-level Non-Object, Non-Array Values"
msgstr "Valores de nivel superior No-Objeto , No-Arreglo"

#: ../Doc/library/json.rst:636
msgid ""
"The old version of JSON specified by the obsolete :rfc:`4627` required that "
"the top-level value of a JSON text must be either a JSON object or array "
"(Python :class:`dict` or :class:`list`), and could not be a JSON null, "
"boolean, number, or string value.  :rfc:`7159` removed that restriction, and "
"this module does not and has never implemented that restriction in either "
"its serializer or its deserializer."
msgstr ""
"La versión anterior de JSON especificada por el obsoleto :rfc:`4627` "
"requería que el valor de nivel superior de un texto JSON fuera un objeto "
"JSON o un arreglo (Python :class:`dict` o :class:`list`), y no podía ser un "
"valor JSON nulo, booleano, numérico o de cadena.  :rfc:`7159` eliminó esa "
"restricción, y este módulo no ha implementado ni ha implementado nunca esa "
"restricción en su serializador o en su deserializador."

#: ../Doc/library/json.rst:643
msgid ""
"Regardless, for maximum interoperability, you may wish to voluntarily adhere "
"to the restriction yourself."
msgstr ""
"Independientemente, para lograr la máxima interoperabilidad, es posible que "
"usted desee adherirse voluntariamente a la restricción."

#: ../Doc/library/json.rst:648
msgid "Implementation Limitations"
msgstr "Limitaciones de la implementación"

#: ../Doc/library/json.rst:650
msgid "Some JSON deserializer implementations may set limits on:"
msgstr ""
"Algunas implementaciones del deserializador JSON pueden establecer límites "
"en:"

#: ../Doc/library/json.rst:652
msgid "the size of accepted JSON texts"
msgstr "el tamaño de los textos JSON aceptados"

#: ../Doc/library/json.rst:653
msgid "the maximum level of nesting of JSON objects and arrays"
msgstr "el nivel máximo de anidamiento de objetos y arreglos JSON"

#: ../Doc/library/json.rst:654
msgid "the range and precision of JSON numbers"
msgstr "el rango y precisión de los números JSON"

#: ../Doc/library/json.rst:655
msgid "the content and maximum length of JSON strings"
msgstr "el contenido y la longitud máxima de las cadenas de caracteres JSON"

#: ../Doc/library/json.rst:657
msgid ""
"This module does not impose any such limits beyond those of the relevant "
"Python datatypes themselves or the Python interpreter itself."
msgstr ""
"Este módulo no impone tales límites más allá de los propios tipos de datos "
"de Python relevantes o del propio intérprete de Python."

#: ../Doc/library/json.rst:660
msgid ""
"When serializing to JSON, beware any such limitations in applications that "
"may consume your JSON.  In particular, it is common for JSON numbers to be "
"deserialized into IEEE 754 double precision numbers and thus subject to that "
"representation's range and precision limitations.  This is especially "
"relevant when serializing Python :class:`int` values of extremely large "
"magnitude, or when serializing instances of \"exotic\" numerical types such "
"as :class:`decimal.Decimal`."
msgstr ""
"Al serializar en JSON, tenga en cuenta las limitaciones en las aplicaciones "
"que pueden consumir su JSON.  En particular, es común que los números JSON "
"se deserialicen en números de doble precisión IEEE 754 y, por lo tanto, "
"estén sujetos al rango y las limitaciones de precisión de esa "
"representación.  Esto es especialmente relevante cuando se serializan "
"valores de Python :class:`int` de magnitud extremadamente grande, o cuando "
"se serializan instancias de tipos numéricos \"exóticos\" como :class:"
"`decimal. Decimal`."

#: ../Doc/library/json.rst:673
msgid "Command Line Interface"
msgstr "Interfaz de línea de comandos"

#: ../Doc/library/json.rst:678
msgid "**Source code:** :source:`Lib/json/tool.py`"
msgstr "**Código fuente:** :source:`Lib/json/tool.py`"

#: ../Doc/library/json.rst:682
msgid ""
"The :mod:`json.tool` module provides a simple command line interface to "
"validate and pretty-print JSON objects."
msgstr ""
"El módulo :mod:`json.tool` proporciona una interfaz de línea de comandos "
"simple para validar e imprimir objetos JSON."

#: ../Doc/library/json.rst:685
#, fuzzy
msgid ""
"If the optional ``infile`` and ``outfile`` arguments are not specified, :"
"data:`sys.stdin` and :data:`sys.stdout` will be used respectively:"
msgstr ""
"Si no se especifican los argumentos opcionales ``infile`` y ``outfile``, se "
"utilizarán :attr:`sys.stdin` y :attr:`sys.stdout` respectivamente:"

#: ../Doc/library/json.rst:697
msgid ""
"The output is now in the same order as the input. Use the :option:`--sort-"
"keys` option to sort the output of dictionaries alphabetically by key."
msgstr ""
"La salida está ahora en el mismo orden que la entrada. Utilice la opción :"
"option:`--sort-keys` para ordenar la salida de los diccionarios "
"alfabéticamente por llave."

#: ../Doc/library/json.rst:704
msgid "Command line options"
msgstr "Opciones de línea de comandos"

#: ../Doc/library/json.rst:708
msgid "The JSON file to be validated or pretty-printed:"
msgstr "El archivo JSON que se va a validar o imprimir con impresión linda:"

#: ../Doc/library/json.rst:724
#, fuzzy
msgid "If *infile* is not specified, read from :data:`sys.stdin`."
msgstr "Si no se especifica *infile*, lee :attr:`sys.stdin`."

#: ../Doc/library/json.rst:728
#, fuzzy
msgid ""
"Write the output of the *infile* to the given *outfile*. Otherwise, write it "
"to :data:`sys.stdout`."
msgstr ""
"Escribe la salida de *infile* en el *outfile* dado. De lo contrario, lo "
"escribe en :attr:`sys.stdout`."

#: ../Doc/library/json.rst:733
msgid "Sort the output of dictionaries alphabetically by key."
msgstr "Ordena la salida de los diccionarios alfabéticamente por llave."

#: ../Doc/library/json.rst:739
msgid ""
"Disable escaping of non-ascii characters, see :func:`json.dumps` for more "
"information."
msgstr ""
"Deshabilita el escape de caracteres que no sean ascii, véase :func:`json."
"dumps` para más información."

#: ../Doc/library/json.rst:745
msgid "Parse every input line as separate JSON object."
msgstr "Analiza cada línea de entrada como objeto JSON independiente."

#: ../Doc/library/json.rst:751
msgid "Mutually exclusive options for whitespace control."
msgstr "Opciones mutuamente exclusivas para control de espacios en blanco."

#: ../Doc/library/json.rst:757
msgid "Show the help message."
msgstr "Muestra el mensaje de ayuda."

#: ../Doc/library/json.rst:761
msgid "Footnotes"
msgstr "Notas de pie de página"

#: ../Doc/library/json.rst:762
msgid ""
"As noted in `the errata for RFC 7159 <https://www.rfc-editor.org/"
"errata_search.php?rfc=7159>`_, JSON permits literal U+2028 (LINE SEPARATOR) "
"and U+2029 (PARAGRAPH SEPARATOR) characters in strings, whereas JavaScript "
"(as of ECMAScript Edition 5.1) does not."
msgstr ""
"Como se indica en `la errata para RFC 7159 <https://www.rfc-editor.org/"
"errata_search.php?rfc-7159>`_, JSON permite caracteres literales U+2028 "
"(SEPARADOR DE LINEA) y U+2029 (SEPARADOR DE PÁRRAFO) en cadenas, mientras "
"que JavaScript (a partir de ECMAScript Edición 5.1) no lo hace."