@pipobscure/xml 0.1.0

package/LICENSE.md

@@ -0,0 +1,190 @@
+EUROPEAN UNION PUBLIC LICENCE v. 1.2
+EUPL © Philipp Dunkel 2026
+
+This European Union Public Licence (the 'EUPL') applies to the Work (as defined below) which is provided under the
+terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such
+use is covered by a right of the copyright holder of the Work).
+The Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following
+notice immediately following the copyright notice for the Work:
+                          Licensed under the EUPL
+or has expressed by any other means his willingness to license under the EUPL.
+
+1.Definitions
+In this Licence, the following terms have the following meaning:
+— 'The Licence':this Licence.
+— 'The Original Work':the work or software distributed or communicated by the Licensor under this Licence, available
+as Source Code and also as Executable Code as the case may be.
+— 'Derivative Works':the works or software that could be created by the Licensee, based upon the Original Work or
+modifications thereof. This Licence does not define the extent of modification or dependence on the Original Work
+required in order to classify a work as a Derivative Work; this extent is determined by copyright law applicable in
+the country mentioned in Article 15.
+— 'The Work':the Original Work or its Derivative Works.
+— 'The Source Code':the human-readable form of the Work which is the most convenient for people to study and
+modify.
+— 'The Executable Code':any code which has generally been compiled and which is meant to be interpreted by
+a computer as a program.
+— 'The Licensor':the natural or legal person that distributes or communicates the Work under the Licence.
+— 'Contributor(s)':any natural or legal person who modifies the Work under the Licence, or otherwise contributes to
+the creation of a Derivative Work.
+— 'The Licensee' or 'You':any natural or legal person who makes any usage of the Work under the terms of the
+Licence.
+— 'Distribution' or 'Communication':any act of selling, giving, lending, renting, distributing, communicating,
+transmitting, or otherwise making available, online or offline, copies of the Work or providing access to its essential
+functionalities at the disposal of any other natural or legal person.
+
+2.Scope of the rights granted by the Licence
+The Licensor hereby grants You a worldwide, royalty-free, non-exclusive, sublicensable licence to do the following, for
+the duration of copyright vested in the Original Work:
+— use the Work in any circumstance and for all usage,
+— reproduce the Work,
+— modify the Work, and make Derivative Works based upon the Work,
+— communicate to the public, including the right to make available or display the Work or copies thereof to the public
+and perform publicly, as the case may be, the Work,
+— distribute the Work or copies thereof,
+— lend and rent the Work or copies thereof,
+— sublicense rights in the Work or copies thereof.
+Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the
+applicable law permits so.
+In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed
+by law in order to make effective the licence of the economic rights here above listed.
+The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to any patents held by the Licensor, to the
+extent necessary to make use of the rights granted on the Work under this Licence.
+
+3.Communication of the Source Code
+The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as
+Executable Code, the Licensor provides in addition a machine-readable copy of the Source Code of the Work along with
+each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to
+the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to
+distribute or communicate the Work.
+
+4.Limitations on copyright
+Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the
+exclusive rights of the rights owners in the Work, of the exhaustion of those rights or of other applicable limitations
+thereto.
+
+5.Obligations of the Licensee
+The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those
+obligations are the following:
+
+Attribution right: The Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to
+the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the
+Licence with every copy of the Work he/she distributes or communicates. The Licensee must cause any Derivative Work
+to carry prominent notices stating that the Work has been modified and the date of modification.
+
+Copyleft clause: If the Licensee distributes or communicates copies of the Original Works or Derivative Works, this
+Distribution or Communication will be done under the terms of this Licence or of a later version of this Licence unless
+the Original Work is expressly distributed only under this version of the Licence — for example by communicating
+'EUPL v. 1.2 only'. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the
+Work or Derivative Work that alter or restrict the terms of the Licence.
+
+Compatibility clause: If the Licensee Distributes or Communicates Derivative Works or copies thereof based upon both
+the Work and another work licensed under a Compatible Licence, this Distribution or Communication can be done
+under the terms of this Compatible Licence. For the sake of this clause, 'Compatible Licence' refers to the licences listed
+in the appendix attached to this Licence. Should the Licensee's obligations under the Compatible Licence conflict with
+his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail.
+
+Provision of Source Code: When distributing or communicating copies of the Work, the Licensee will provide
+a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available
+for as long as the Licensee continues to distribute or communicate the Work.
+Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or names
+of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the copyright notice.
+
+6.Chain of Authorship
+The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or
+licensed to him/her and that he/she has the power and authority to grant the Licence.
+Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or
+licensed to him/her and that he/she has the power and authority to grant the Licence.
+Each time You accept the Licence, the original Licensor and subsequent Contributors grant You a licence to their contributions
+to the Work, under the terms of this Licence.
+
+7.Disclaimer of Warranty
+The Work is a work in progress, which is continuously improved by numerous Contributors. It is not a finished work
+and may therefore contain defects or 'bugs' inherent to this type of development.
+For the above reason, the Work is provided under the Licence on an 'as is' basis and without warranties of any kind
+concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or
+errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this
+Licence.
+This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work.
+
+8.Disclaimer of Liability
+Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be
+liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the
+Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss
+of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However,
+the Licensor will be liable under statutory product liability laws as far such laws apply to the Work.
+
+9.Additional agreements
+While distributing the Work, You may choose to conclude an additional agreement, defining obligations or services
+consistent with this Licence. However, if accepting obligations, You may act only on your own behalf and on your sole
+responsibility, not on behalf of the original Licensor or any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against such Contributor by
+the fact You have accepted any warranty or additional liability.
+
+10.Acceptance of the Licence
+The provisions of this Licence can be accepted by clicking on an icon 'I agree' placed under the bottom of a window
+displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of
+applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms
+and conditions.
+Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You
+by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution
+or Communication by You of the Work or copies thereof.
+
+11.Information to the public
+In case of any Distribution or Communication of the Work by means of electronic communication by You (for example,
+by offering to download the Work from a remote location) the distribution channel or media (for example, a website)
+must at least provide to the public the information requested by the applicable law regarding the Licensor, the Licence
+and the way it may be accessible, concluded, stored and reproduced by the Licensee.
+
+12.Termination of the Licence
+The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms
+of the Licence.
+Such a termination will not terminate the licences of any person who has received the Work from the Licensee under
+the Licence, provided such persons remain in full compliance with the Licence.
+
+13.Miscellaneous
+Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the
+Work.
+If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or
+enforceability of the Licence as a whole. Such provision will be construed or reformed so as necessary to make it valid
+and enforceable.
+The European Commission may publish other linguistic versions or new versions of this Licence or updated versions of
+the Appendix, so far this is required and reasonable, without reducing the scope of the rights granted by the Licence.
+New versions of the Licence will be published with a unique version number.
+All linguistic versions of this Licence, approved by the European Commission, have identical value. Parties can take
+advantage of the linguistic version of their choice.
+
+14.Jurisdiction
+Without prejudice to specific agreement between parties,
+— any litigation resulting from the interpretation of this License, arising between the European Union institutions,
+bodies, offices or agencies, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice
+of the European Union, as laid down in article 272 of the Treaty on the Functioning of the European Union,
+— any litigation arising between other parties and resulting from the interpretation of this License, will be subject to
+the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business.
+
+15.Applicable Law
+Without prejudice to specific agreement between parties,
+— this Licence shall be governed by the law of the European Union Member State where the Licensor has his seat,
+resides or has his registered office,
+— this licence shall be governed by Belgian law if the Licensor has no seat, residence or registered office inside
+a European Union Member State.
+
+
+                                                         Appendix
+
+'Compatible Licences' according to Article 5 EUPL are:
+— GNU General Public License (GPL) v. 2, v. 3
+— GNU Affero General Public License (AGPL) v. 3
+— Open Software License (OSL) v. 2.1, v. 3.0
+— Eclipse Public License (EPL) v. 1.0
+— CeCILL v. 2.0, v. 2.1
+— Mozilla Public Licence (MPL) v. 2
+— GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3
+— Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for works other than software
+— European Union Public Licence (EUPL) v. 1.1, v. 1.2
+— Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong Reciprocity (LiLiQ-R+).
+
+The European Commission may update this Appendix to later versions of the above licences without producing
+a new version of the EUPL, as long as they provide the rights granted in Article 2 of this Licence and protect the
+covered Source Code from exclusive appropriation.
+All other changes or additions to this Appendix require the production of a new EUPL version.

package/README.md

@@ -0,0 +1,396 @@
+# @pipobscure/xml
+
+A fully capable, forgiving XML parser for TypeScript and JavaScript. Produces plain JS objects that are JSON-serialisable, well-typed, and straightforward to traverse.
+
+Designed for CalDAV, CardDAV, WebDAV, Atom, and similar document-oriented XML workloads where documents are small, real-world servers are quirky, and zero dependencies are preferred.
+
+## Features
+
+- Full namespace support (prefix resolution, default namespace, `xmlns=""` undeclaration)
+- All XML node types: elements, text, CDATA, comments, processing instructions, DOCTYPE, XML declaration
+- Tolerant parsing — recovers gracefully from many real-world quirks instead of throwing
+- Plain-object output — every node is a simple JS object, safe to `JSON.stringify` and `JSON.parse`
+- Discriminated union type hierarchy — narrow any node to its concrete type with `instanceof`-free type guards
+- Tree query helpers — a small functional API for locating elements and reading text
+- Serializer — converts any node back to an XML string
+- Zero dependencies, pure TypeScript, ESM
+
+## Installation
+
+```sh
+npm install @pipobscure/xml
+```
+
+## Quick start
+
+```ts
+import { parse, rootElement, child, attr, textContent, serialize } from '@pipobscure/xml';
+
+const doc = parse(`<?xml version="1.0" encoding="utf-8"?>
+  <D:propfind xmlns:D="DAV:">
+    <D:prop>
+      <D:displayname/>
+      <D:getcontenttype/>
+    </D:prop>
+  </D:propfind>`);
+
+const root = rootElement(doc);             // Element — <D:propfind>
+const prop = child(root, 'prop', 'DAV:'); // Element — <D:prop>
+console.log(prop?.children.length);       // 2
+
+// Serialize back to XML
+const xml = serialize(doc);
+```
+
+---
+
+## API reference
+
+### `parse(xml: string): Document`
+
+Parses an XML string and returns a `Document` node. Never throws for malformed input — the parser is deliberately tolerant (see [Tolerance](#tolerance) below). It does throw `ParseError` for hard structural failures such as a completely empty input.
+
+```ts
+import { parse } from '@pipobscure/xml';
+
+const doc = parse('<root attr="hello">world</root>');
+// doc.type === 'document'
+// doc.children[0].type === 'element'
+```
+
+### `class ParseError extends Error`
+
+Thrown by `parse()` only for unrecoverable failures. Carries three extra properties:
+
+| Property | Type | Description |
+|---|---|---|
+| `position` | `number` | Byte offset in the source string |
+| `line` | `number` | 1-based line number |
+| `column` | `number` | 1-based column number |
+
+---
+
+## Node types
+
+Every node has a `type` discriminant. All nodes are plain JS objects with readonly properties.
+
+### `Document`
+
+The root container returned by `parse()`.
+
+```ts
+interface Document {
+  readonly type: 'document';
+  readonly children: ReadonlyArray<DocumentChild>;
+}
+```
+
+`DocumentChild` is the union `XmlDeclaration | DocumentType | Element | Comment | ProcessingInstruction`.
+
+### `Element`
+
+```ts
+interface Element {
+  readonly type: 'element';
+  readonly name: string;           // local name
+  readonly prefix: string | null;  // namespace prefix, or null
+  readonly namespace: string | null; // resolved namespace URI, or null
+  readonly attributes: ReadonlyArray<Attribute>;
+  readonly children: ReadonlyArray<ChildNode>;
+}
+```
+
+`ChildNode` is the union `Element | Text | CData | Comment | ProcessingInstruction`.
+
+### `Attribute`
+
+```ts
+interface Attribute {
+  readonly name: string;           // local name
+  readonly prefix: string | null;  // namespace prefix, or null
+  readonly namespace: string | null; // resolved namespace URI, or null
+  readonly value: string;          // decoded value
+}
+```
+
+Namespace-declaration attributes (`xmlns`, `xmlns:prefix`) are included in the `attributes` array with their namespace resolved to `http://www.w3.org/2000/xmlns/`. Unprefixed attributes carry `namespace: null` — they do not inherit the element's default namespace, per the XML Namespaces specification.
+
+### `Text`
+
+```ts
+interface Text {
+  readonly type: 'text';
+  readonly value: string; // decoded character content
+}
+```
+
+### `CData`
+
+```ts
+interface CData {
+  readonly type: 'cdata';
+  readonly value: string; // raw CDATA content (between <![CDATA[ and ]]>)
+}
+```
+
+### `Comment`
+
+```ts
+interface Comment {
+  readonly type: 'comment';
+  readonly value: string; // text between <!-- and -->
+}
+```
+
+### `ProcessingInstruction`
+
+```ts
+interface ProcessingInstruction {
+  readonly type: 'processing-instruction';
+  readonly target: string; // PI target
+  readonly data: string;   // everything after the target, leading whitespace stripped
+}
+```
+
+### `XmlDeclaration`
+
+```ts
+interface XmlDeclaration {
+  readonly type: 'xml-declaration';
+  readonly version: string;
+  readonly encoding: string | null;
+  readonly standalone: boolean | null;
+}
+```
+
+### `DocumentType`
+
+```ts
+interface DocumentType {
+  readonly type: 'doctype';
+  readonly name: string;
+  readonly publicId: string | null;
+  readonly systemId: string | null;
+  readonly internalSubset: string | null; // verbatim, unparsed
+}
+```
+
+### Union aliases
+
+| Alias | Members |
+|---|---|
+| `ChildNode` | `Element \| Text \| CData \| Comment \| ProcessingInstruction` |
+| `DocumentChild` | `XmlDeclaration \| DocumentType \| Element \| Comment \| ProcessingInstruction` |
+| `AnyNode` | All eight concrete types |
+
+---
+
+## Type guards
+
+Each node type has a corresponding type guard that doubles as a discriminating predicate:
+
+```ts
+import {
+  isDocument, isElement, isText, isCData,
+  isComment, isProcessingInstruction, isDocumentType, isXmlDeclaration,
+} from '@pipobscure/xml';
+
+for (const node of doc.children) {
+  if (isElement(node)) {
+    console.log(node.name, node.namespace);
+  }
+}
+```
+
+All guards have the signature `(node: Node) => node is T`.
+
+---
+
+## Tree query helpers
+
+A small set of functions for navigating the document tree. All helpers are **tolerant**: they accept `null` and `undefined` and return the neutral value (`undefined`, `[]`, `""`, `0`) rather than throwing.
+
+### `rootElement(doc)`
+
+```ts
+rootElement(doc: Document | null | undefined): Element | undefined
+```
+
+Returns the first element child of a `Document`, or `undefined`.
+
+### `child(el, name, ns?)`
+
+```ts
+child(el: Element | null | undefined, name: string, ns?: string): Element | undefined
+```
+
+Returns the first direct child element with the given local name and (optionally) namespace URI.
+
+### `requireChild(el, name, ns?)`
+
+```ts
+requireChild(el: Element | null | undefined, name: string, ns?: string): Element
+```
+
+Like `child`, but throws a descriptive `Error` when the element is not found. Useful for strict processing where a missing child is a hard failure.
+
+### `children(el, name, ns?)`
+
+```ts
+children(el: Element | null | undefined, name: string, ns?: string): Element[]
+```
+
+Returns all direct child elements with the given local name and optional namespace URI.
+
+### `childElements(el)`
+
+```ts
+childElements(el: Element | null | undefined): Element[]
+```
+
+Returns all direct child elements regardless of name or namespace.
+
+### `childElementCount(el)`
+
+```ts
+childElementCount(el: Element | null | undefined): number
+```
+
+Returns the number of direct child elements.
+
+### `descendant(node, name, ns?)`
+
+```ts
+descendant(
+  node: Document | Element | null | undefined,
+  name: string,
+  ns?: string,
+): Element | undefined
+```
+
+Returns the first element anywhere in the subtree with the given local name and optional namespace URI. Depth-first, pre-order.
+
+### `descendants(node, name, ns?)`
+
+```ts
+descendants(
+  node: Document | Element | null | undefined,
+  name: string,
+  ns?: string,
+): Element[]
+```
+
+Returns all elements anywhere in the subtree with the given local name and optional namespace URI.
+
+### `textContent(node)`
+
+```ts
+textContent(node: AnyNode | null | undefined): string
+```
+
+Concatenates all `Text` and `CData` content in the subtree, equivalent to the DOM's `element.textContent`. Returns `""` for node types that carry no text (comments, PIs, etc.).
+
+### `attr(el, name, ns?)`
+
+```ts
+attr(el: Element | null | undefined, name: string, ns?: string): string | undefined
+```
+
+Returns the value of the attribute with the given local name and optional namespace URI, or `undefined` if not found.
+
+### Example — CalDAV response
+
+```ts
+import { parse, rootElement, children, child, textContent, attr } from '@pipobscure/xml';
+
+const doc = parse(calDavMultistatusXml);
+const root = rootElement(doc);
+
+for (const response of children(root, 'response', 'DAV:')) {
+  const href   = textContent(child(response, 'href', 'DAV:'));
+  const status = textContent(child(response, 'status', 'DAV:'));
+  console.log(href, status);
+}
+```
+
+---
+
+## Serializer
+
+### `serialize(node)`
+
+```ts
+serialize(node: AnyNode | null | undefined): string
+```
+
+Converts any node (or a complete `Document`) back to an XML string.
+
+| Input type | Output |
+|---|---|
+| `Document` | All children concatenated |
+| `Element` | `<tag attrs>…</tag>`, or `<tag attrs/>` when childless |
+| `Text` | Character-escaped text (`&`, `<`, `>` → entities) |
+| `CData` | `<![CDATA[…]]>`, splitting on embedded `]]>` |
+| `Comment` | `<!--…-->` |
+| `ProcessingInstruction` | `<?target data?>` |
+| `XmlDeclaration` | `<?xml version="…" …?>` |
+| `DocumentType` | `<!DOCTYPE …>` |
+| `null` / `undefined` | `""` |
+
+The serializer is tolerant of the same kind of incomplete objects as the query helpers — missing `children`, `attributes`, or `prefix` properties are treated as empty/absent rather than causing a throw.
+
+**Round-trip guarantee.** For any valid XML document, `parse(serialize(parse(xml)))` produces a tree that is deeply equal to `parse(xml)`. Character content is re-escaped on serialize and re-decoded on re-parse, so the tree comparison holds even when the source used unescaped `>` or non-canonical entity forms.
+
+**CDATA with `]]>`.** The sequence `]]>` inside a CDATA value is split across two adjacent CDATA sections so that the output remains well-formed. The text content is preserved exactly; only the tree structure changes (one `CData` node becomes two).
+
+```ts
+import { parse, serialize } from '@pipobscure/xml';
+
+const doc  = parse('<root><![CDATA[<em>bold</em>]]></root>');
+const xml  = serialize(doc);
+// '<root><![CDATA[<em>bold</em>]]></root>'
+
+const doc2 = parse(xml);
+// deepEqual(doc2, doc) === true
+```
+
+---
+
+## Tolerance
+
+The parser is designed to handle the kind of non-conformant XML that real-world CalDAV and CardDAV servers emit. Specifically:
+
+| Quirk | Behaviour |
+|---|---|
+| UTF-8 BOM | Silently skipped |
+| No XML declaration | Parsed without error |
+| Unknown named entities (`&nbsp;`) | Preserved verbatim (`&nbsp;`) |
+| Bare `&` with no entity name | Emitted as `&` literally |
+| Undeclared namespace prefix | Resolved to `null`; no throw |
+| `--` inside a comment | Allowed |
+| Attribute values with either quote style | Accepted |
+| DOCTYPE internal subset | Captured verbatim, not validated |
+| Mismatched closing tag | Tolerated |
+
+The query helpers and serializer apply the same philosophy: missing or wrong-typed properties on nodes (e.g. a JSON-deserialised object missing its `children` array) are treated as absent or empty, never as fatal errors.
+
+---
+
+## JSON serialisation
+
+All parse output is composed of plain objects and primitive values — no class instances, no `undefined` values, no circular references. A document tree can be safely round-tripped through `JSON.stringify` / `JSON.parse`:
+
+```ts
+const doc  = parse(xml);
+const json = JSON.stringify(doc);
+const doc2 = JSON.parse(json);
+
+// Query helpers work on the revived object exactly as on the original:
+const root = rootElement(doc2);
+```
+
+---
+
+## License
+
+[EUPL-1.2](LICENSE) — European Union Public Licence v. 1.2

package/dist/chars.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @pipobscure/xml — XML character classification
+ *
+ * All functions operate on numeric Unicode code points (from `charCodeAt`)
+ * for maximum performance on the ASCII-heavy content typical of
+ * CalDAV / CardDAV payloads.
+ *
+ * The ranges follow XML 1.0 (fifth edition) §2.2 and the XML Namespaces 1.0
+ * specification. The parser itself is tolerant and will not reject documents
+ * solely on character-class grounds, but these helpers are used to drive the
+ * tokeniser for correct name recognition.
+ */
+/** XML whitespace: space, tab, carriage-return, newline. */
+export declare function isXmlWhitespace(code: number): boolean;
+/**
+ * Valid XML NameStartChar (includes `:` so that QNames can be lexed as a
+ * single token and split on `:` afterwards).
+ *
+ * XML 1.0 §2.3 production [4]
+ */
+export declare function isNameStartChar(code: number): boolean;
+/**
+ * Valid XML NameChar (superset of NameStartChar).
+ *
+ * XML 1.0 §2.3 production [4a]
+ */
+export declare function isNameChar(code: number): boolean;
+/** ASCII hex digit [0-9A-Fa-f]. */
+export declare function isHexDigit(code: number): boolean;
+/** ASCII decimal digit [0-9]. */
+export declare function isDecimalDigit(code: number): boolean;
+//# sourceMappingURL=chars.d.ts.map

package/dist/chars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chars.d.ts","sourceRoot":"","sources":["../src/chars.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CA4BrD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQhD;AAED,mCAAmC;AACnC,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMhD;AAED,iCAAiC;AACjC,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD"}