@kaeawc/auto-mobile 0.0.91 → 0.0.92

package/node_modules/token-types/README.md

@@ -1,160 +0,0 @@
-[![Node.js CI](https://github.com/Borewit/token-types/actions/workflows/nodejs-ci.yml/badge.svg?branch=master)](https://github.com/Borewit/token-types/actions/workflows/nodejs-ci.yml?query=branch%3Amaster)
-[![NPM version](https://badge.fury.io/js/token-types.svg)](https://npmjs.org/package/token-types)
-[![npm downloads](http://img.shields.io/npm/dm/token-types.svg)](https://npmcharts.com/compare/token-types,strtok3?start=1200&interval=30)
-[![codecov](https://codecov.io/gh/Borewit/token-types/branch/master/graph/badge.svg)](https://codecov.io/gh/Borewit/token-types)
-[![DeepScan grade](https://deepscan.io/api/teams/5165/projects/6940/branches/61852/badge/grade.svg)](https://deepscan.io/dashboard#view=project&tid=5165&pid=6940&bid=61852)
-[![Known Vulnerabilities](https://snyk.io/test/github/Borewit/token-types/badge.svg?targetFile=package.json)](https://snyk.io/test/github/Borewit/token-types?targetFile=package.json)
-
-# token-types
-
-A primitive token library used to read and write from a `Uint8Array`.
-Although it is possible to use this module directly, it is primarily designed to be used with [strtok3 tokenizer](https://github.com/Borewit/strtok3).
-
-## Compatibility
-
-Module: version 5 migrated from [CommonJS](https://en.wikipedia.org/wiki/CommonJS) to [pure ECMAScript Module (ESM)](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c).
-JavaScript is compliant with [ECMAScript 2019 (ES10)](https://en.wikipedia.org/wiki/ECMAScript#10th_Edition_%E2%80%93_ECMAScript_2019).
-
-Node.js 18 is supported for running the published package; it is not a supported
-build environment. The test toolchain requires Node.js 22.12 or later. CI builds
-on Node.js 24 and runs the tests on Node.js 22, 24 and 26.
-
-## Development
-
-Use Node.js 24 and the Yarn version pinned in `package.json` to install development
-dependencies and build from source:
-
-```sh
-corepack enable
-yarn install --immutable
-yarn test
-```
-
-`yarn test` type-checks the sources and runs the Vitest suite against the
-TypeScript sources. `yarn test:watch` runs Vitest in watch mode, and
-`yarn test-coverage` writes text and LCOV reports to `coverage`. `yarn clean`
-removes `dist` and coverage.
-
-`yarn lint` checks the Markdown and Biome rules. `yarn format:check` verifies
-Biome formatting, and `yarn fix` applies formatting, import organization and
-safe lint fixes.
-
-## Installation
-
-```sh
-npm install --save token-types
-```
-Usually in combination with [strtok3](https://github.com/Borewit/strtok3):
-```sh
-npm install --save strtok3
-```
-
-Using TypeScript you should also install [@tokenizer/token](https://github.com/Borewit/tokenizer-token) as a development
-dependency:
-
-```shell
-npm install --save-dev @tokenizer/token
-```
-
-
-## Example
-
-```js
-import * as strtok3 from 'strtok3';
-import * as token from 'token-types';
-
-(async () => {
-
-  const tokenizer = await strtok3.fromFile("somefile.bin");
-  try {
-    const myNumber = await tokenizer.readToken(token.Float32_BE);
-    console.log(`My number: ${myNumber}`);
-  } finally {
-    tokenizer.close(); // Close the file
-  }
-})();
-```
-
-## Tokens
-
-### Numeric tokens
-
-`token-types` supports a wide variety of numeric tokens out of the box:
-
-| Token         | Number           | Bits | Endianness     |
-|---------------|------------------|------|----------------|
-| `UINT8`       | Unsigned integer |    8 | n/a            |
-| `UINT16_BE`   | Unsigned integer |   16 | big endian     |
-| `UINT16_LE`   | Unsigned integer |   16 | little endian  |
-| `UINT24_BE`   | Unsigned integer |   24 | big endian     |
-| `UINT24_LE`   | Unsigned integer |   24 | little endian  |
-| `UINT32_BE`   | Unsigned integer |   32 | big endian     |
-| `UINT32_LE`   | Unsigned integer |   32 | little endian  |
-| `UINT64_BE`   | Unsigned integer |   64 | big endian     |
-| `UINT64_LE`*  | Unsigned integer |   64 | little endian  |
-| `INT8`        | Signed integer   |    8 | n/a            |
-| `INT16_BE`    | Signed integer   |   16 | big endian     |
-| `INT16_LE`    | Signed integer   |   16 | little endian  |
-| `INT24_BE`    | Signed integer   |   24 | big endian     |
-| `INT24_LE`    | Signed integer   |   24 | little endian  |
-| `INT32_BE`    | Signed integer   |   32 | big endian     |
-| `INT32_LE`    | Signed integer   |   32 | little endian  |
-| `INT64_BE`    | Signed integer   |   64 | big endian     |
-| `INT64_LE`*   | Signed integer   |   64 | little endian  |
-| `Float16_BE`  | IEEE 754 float   |   16 | big endian     |
-| `Float16_LE`  | IEEE 754 float   |   16 | little endian  |
-| `Float32_BE`  | IEEE 754 float   |   32 | big endian     |
-| `Float32_LE`  | IEEE 754 float   |   32 | little endian  |
-| `Float64_BE`  | IEEE 754 float   |   64 | big endian     |
-| `Float64_LE`  | IEEE 754 float   |   64 | little endian  |
-| `Float80_BE`* | IEEE 754 float   |   80 | big endian     |
-| `Float80_LE`* | IEEE 754 float   |   80 | little endian  |
-
-(*) The tokens exceed the JavaScript IEEE 754 64-bit Floating Point precision, decoding and encoding is best effort based.
-
-### String and byte tokens
-
-`StringType` decoding is using [@borewit/text-codec](https://github.com/Borewit/text-codec).
-
-`StringType` and `Uint8ArrayType` implement `IToken`, so the same fixed-size
-token can decode and encode:
-
-```js
-import { StringType, Uint8ArrayType } from 'token-types';
-
-const ascii = new StringType(4, 'ascii');
-const buffer = new Uint8Array(8);
-ascii.put(buffer, 0, 'fLaC');
-
-const bytes = new Uint8ArrayType(4);
-bytes.put(buffer, 4, Uint8Array.from([1, 2, 3, 4]));
-```
-
-`put` rejects values whose byte length differs from `len`, so a fixed-size
-field is never silently truncated or padded.
-
-### Custom tokens
-
-Custom tokens can be added, suitable for reading binary files or network messages:
-```js
-  ExtendedHeader = {
-    len: 10,
-
-    get: (buf, off) => {
-      return {
-        // Extended header size
-        size: Token.UINT32_BE.get(buf, off),
-        // Extended Flags
-        extendedFlags: Token.UINT16_BE.get(buf, off + 4),
-        // Size of padding
-        sizeOfPadding: Token.UINT32_BE.get(buf, off + 6),
-        // CRC data present
-        crcDataPresent: common.strtokBITSET.get(buf, off + 4, 31)
-      };
-    }
-  };
-```
-
-## Licence
-
-This project is licensed under the [MIT License](LICENSE.txt). Feel free to use, modify, and distribute as needed.

package/node_modules/uint8array-extras/readme.md

@@ -1,318 +0,0 @@
-# uint8array-extras
-
-> Useful utilities for working with [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) (and [`Buffer`](https://nodejs.org/api/buffer.html))
-
-It's time to [transition from `Buffer` to `Uint8Array`](https://sindresorhus.com/blog/goodbye-nodejs-buffer), and this package helps fill in the gaps.
-
-Note that `Buffer` is a `Uint8Array` subclass, so you can use this package with `Buffer` too.
-
-This package is tree-shakeable and browser-compatible.
-
-This package also includes methods to convert a string to Base64 and back.
-
-Note: In the browser, do not use [`globalThis.atob()`](https://developer.mozilla.org/en-US/docs/Web/API/atob) / [`globalThis.btoa()`](https://developer.mozilla.org/en-US/docs/Web/API/btoa) because they [do not support Unicode](https://developer.mozilla.org/en-US/docs/Glossary/Base64#the_unicode_problem). This package does.
-
-## Install
-
-```sh
-npm install uint8array-extras
-```
-
-## Usage
-
-```js
-import {concatUint8Arrays} from 'uint8array-extras';
-
-const a = new Uint8Array([1, 2, 3]);
-const b = new Uint8Array([4, 5, 6]);
-
-console.log(concatUint8Arrays([a, b]));
-//=> Uint8Array [1, 2, 3, 4, 5, 6]
-```
-
-## API
-
-### `isUint8Array(value: unknown): boolean`
-
-Check if the given value is an instance of `Uint8Array`.
-
-Replacement for [`Buffer.isBuffer()`](https://nodejs.org/api/buffer.html#static-method-bufferisbufferobj).
-
-```js
-import {isUint8Array} from 'uint8array-extras';
-
-console.log(isUint8Array(new Uint8Array()));
-//=> true
-
-console.log(isUint8Array(Buffer.from('x')));
-//=> true
-
-console.log(isUint8Array(new ArrayBuffer(10)));
-//=> false
-```
-
-### `assertUint8Array(value: unknown)`
-
-Throw a `TypeError` if the given value is not an instance of `Uint8Array`.
-
-```js
-import {assertUint8Array} from 'uint8array-extras';
-
-try {
-	assertUint8Array(new ArrayBuffer(10)); // Throws a TypeError
-} catch (error) {
-	console.error(error.message);
-}
-```
-
-### `assertUint8ArrayOrArrayBuffer(value: unknown)`
-
-Throw a `TypeError` if the given value is not an instance of `Uint8Array` or `ArrayBuffer`.
-
-Useful as a guard for functions that accept either a `Uint8Array` or `ArrayBuffer`.
-
-```js
-import {assertUint8ArrayOrArrayBuffer} from 'uint8array-extras';
-
-assertUint8ArrayOrArrayBuffer(new Uint8Array());
-assertUint8ArrayOrArrayBuffer(new ArrayBuffer(8));
-```
-
-### `toUint8Array(value: TypedArray | ArrayBuffer | DataView): Uint8Array`
-
-Convert a value to a `Uint8Array` without copying its data.
-
-This can be useful for converting a `Buffer` to a pure `Uint8Array`. `Buffer` is already a `Uint8Array` subclass, but [`Buffer` alters some behavior](https://sindresorhus.com/blog/goodbye-nodejs-buffer), so it can be useful to cast it to a pure `Uint8Array` before returning it.
-
-Tip: If you want a copy, just call `.slice()` on the return value.
-
-### `concatUint8Arrays(arrays: Array<Uint8Array | ArrayBuffer>, totalLength?: number): Uint8Array`
-
-Concatenate the given arrays into a new array.
-
-If `arrays` is empty, it will return a zero-sized `Uint8Array`.
-
-If `totalLength` is not specified, it is calculated from summing the lengths of the given arrays.
-
-Replacement for [`Buffer.concat()`](https://nodejs.org/api/buffer.html#static-method-bufferconcatlist-totallength).
-
-```js
-import {concatUint8Arrays} from 'uint8array-extras';
-
-const a = new Uint8Array([1, 2, 3]);
-const b = new Uint8Array([4, 5, 6]);
-
-console.log(concatUint8Arrays([a, b]));
-//=> Uint8Array [1, 2, 3, 4, 5, 6]
-```
-
-### `areUint8ArraysEqual(a: Uint8Array | ArrayBuffer, b: Uint8Array | ArrayBuffer): boolean`
-
-Check if two arrays are identical by verifying that they contain the same bytes in the same sequence.
-
-Replacement for [`Buffer#equals()`](https://nodejs.org/api/buffer.html#bufequalsotherbuffer).
-
-```js
-import {areUint8ArraysEqual} from 'uint8array-extras';
-
-const a = new Uint8Array([1, 2, 3]);
-const b = new Uint8Array([1, 2, 3]);
-const c = new Uint8Array([4, 5, 6]);
-
-console.log(areUint8ArraysEqual(a, b));
-//=> true
-
-console.log(areUint8ArraysEqual(a, c));
-//=> false
-```
-
-### `compareUint8Arrays(a: Uint8Array | ArrayBuffer, b: Uint8Array | ArrayBuffer): 0 | 1 | -1`
-
-Compare two arrays and indicate their relative order or equality. Useful for sorting.
-
-Replacement for [`Buffer.compare()`](https://nodejs.org/api/buffer.html#static-method-buffercomparebuf1-buf2).
-
-```js
-import {compareUint8Arrays} from 'uint8array-extras';
-
-const array1 = new Uint8Array([1, 2, 3]);
-const array2 = new Uint8Array([4, 5, 6]);
-const array3 = new Uint8Array([7, 8, 9]);
-
-[array3, array1, array2].sort(compareUint8Arrays);
-//=> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
-```
-
-### `uint8ArrayToString(array: Uint8Array | ArrayBuffer, encoding?: string = 'utf8'): string`
-
-Convert a `Uint8Array` to a string.
-
-- Parameter: `encoding` - The [encoding](https://developer.mozilla.org/en-US/docs/Web/API/Encoding_API/Encodings) to convert from.
-
-Replacement for [`Buffer#toString()`](https://nodejs.org/api/buffer.html#buftostringencoding-start-end). For the `encoding` parameter, `latin1` should be used instead of `binary` and `utf-16le` instead of `utf16le`.
-
-```js
-import {uint8ArrayToString} from 'uint8array-extras';
-
-const byteArray = new Uint8Array([72, 101, 108, 108, 111]);
-console.log(uint8ArrayToString(byteArray));
-//=> 'Hello'
-
-const zh = new Uint8Array([167, 65, 166, 110]);
-console.log(uint8ArrayToString(zh, 'big5'));
-//=> '你好'
-
-const ja = new Uint8Array([130, 177, 130, 241, 130, 201, 130, 191, 130, 205]);
-console.log(uint8ArrayToString(ja, 'shift-jis'));
-//=> 'こんにちは'
-```
-
-### `stringToUint8Array(string: string): Uint8Array`
-
-Convert a string to a `Uint8Array` (using UTF-8 encoding).
-
-Replacement for [`Buffer.from('Hello')`](https://nodejs.org/api/buffer.html#static-method-bufferfromstring-encoding).
-
-```js
-import {stringToUint8Array} from 'uint8array-extras';
-
-console.log(stringToUint8Array('Hello'));
-//=> Uint8Array [72, 101, 108, 108, 111]
-```
-
-### `uint8ArrayToBase64(array: Uint8Array | ArrayBuffer, options?: {urlSafe: boolean}): string`
-
-Convert a `Uint8Array` to a Base64-encoded string.
-
-Specify `{urlSafe: true}` to get a [Base64URL](https://base64.guru/standards/base64url)-encoded string.
-
-Replacement for [`Buffer#toString('base64')`](https://nodejs.org/api/buffer.html#buftostringencoding-start-end).
-
-```js
-import {uint8ArrayToBase64} from 'uint8array-extras';
-
-const byteArray = new Uint8Array([72, 101, 108, 108, 111]);
-
-console.log(uint8ArrayToBase64(byteArray));
-//=> 'SGVsbG8='
-```
-
-### `base64ToUint8Array(string: string): Uint8Array`
-
-Convert a Base64-encoded or [Base64URL](https://base64.guru/standards/base64url)-encoded string to a `Uint8Array`.
-
-Accepts Base64URL with or without padding.
-
-Replacement for [`Buffer.from('SGVsbG8=', 'base64')`](https://nodejs.org/api/buffer.html#static-method-bufferfromstring-encoding).
-
-```js
-import {base64ToUint8Array} from 'uint8array-extras';
-
-console.log(base64ToUint8Array('SGVsbG8='));
-//=> Uint8Array [72, 101, 108, 108, 111]
-```
-
-### `stringToBase64(string: string, options?: {urlSafe: boolean}): string`
-
-Encode a string to a Base64-encoded string.
-
-Specify `{urlSafe: true}` to get a [Base64URL](https://base64.guru/standards/base64url)-encoded string.
-
-Replacement for `Buffer.from('Hello').toString('base64')` and [`btoa()`](https://developer.mozilla.org/en-US/docs/Web/API/btoa).
-
-```js
-import {stringToBase64} from 'uint8array-extras';
-
-console.log(stringToBase64('Hello'));
-//=> 'SGVsbG8='
-```
-
-### `base64ToString(base64String: string): string`
-
-Decode a Base64-encoded or [Base64URL](https://base64.guru/standards/base64url)-encoded string to a string.
-
-Accepts Base64URL with or without padding.
-
-Replacement for `Buffer.from('SGVsbG8=', 'base64').toString()` and [`atob()`](https://developer.mozilla.org/en-US/docs/Web/API/atob).
-
-```js
-import {base64ToString} from 'uint8array-extras';
-
-console.log(base64ToString('SGVsbG8='));
-//=> 'Hello'
-```
-
-### `uint8ArrayToHex(array: Uint8Array | ArrayBuffer): string`
-
-Convert a `Uint8Array` to a Hex string.
-
-Replacement for [`Buffer#toString('hex')`](https://nodejs.org/api/buffer.html#buftostringencoding-start-end).
-
-```js
-import {uint8ArrayToHex} from 'uint8array-extras';
-
-const byteArray = new Uint8Array([72, 101, 108, 108, 111]);
-
-console.log(uint8ArrayToHex(byteArray));
-//=> '48656c6c6f'
-```
-
-### `hexToUint8Array(hexString: string): Uint8Array`
-
-Convert a Hex string to a `Uint8Array`.
-
-Replacement for [`Buffer.from('48656c6c6f', 'hex')`](https://nodejs.org/api/buffer.html#static-method-bufferfromstring-encoding).
-
-```js
-import {hexToUint8Array} from 'uint8array-extras';
-
-console.log(hexToUint8Array('48656c6c6f'));
-//=> Uint8Array [72, 101, 108, 108, 111]
-```
-
-### `getUintBE(view: DataView): number`
-
-Read `DataView#byteLength` number of bytes from the given view, up to 48-bit.
-
-Replacement for [`Buffer#readUIntBE`](https://nodejs.org/api/buffer.html#bufreaduintbeoffset-bytelength)
-
-```js
-import {getUintBE} from 'uint8array-extras';
-
-const byteArray = new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);
-
-console.log(getUintBE(new DataView(byteArray.buffer)));
-//=> 20015998341291
-```
-
-### `indexOf(array: Uint8Array | ArrayBuffer, value: Uint8Array | ArrayBuffer): number`
-
-Find the index of the first occurrence of the given sequence of bytes (`value`) within the given `Uint8Array` (`array`).
-
-Replacement for [`Buffer#indexOf`](https://nodejs.org/api/buffer.html#bufindexofvalue-byteoffset-encoding). `Uint8Array#indexOf` only takes a number which is different from Buffer's `indexOf` implementation.
-
-```js
-import {indexOf} from 'uint8array-extras';
-
-const byteArray = new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef]);
-
-console.log(indexOf(byteArray, new Uint8Array([0x78, 0x90])));
-//=> 3
-```
-
-### `includes(array: Uint8Array | ArrayBuffer, value: Uint8Array | ArrayBuffer): boolean`
-
-Checks if the given sequence of bytes (`value`) is within the given `Uint8Array` (`array`).
-
-Returns true if the value is included, otherwise false.
-
-Replacement for [`Buffer#includes`](https://nodejs.org/api/buffer.html#bufincludesvalue-byteoffset-encoding). `Uint8Array#includes` only takes a number which is different from Buffer's `includes` implementation.
-
-```js
-import {includes} from 'uint8array-extras';
-
-const byteArray = new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef]);
-
-console.log(includes(byteArray, new Uint8Array([0x78, 0x90])));
-//=> true
-```

package/node_modules/xml-parse-from-string/README.md

@@ -1,35 +0,0 @@
-# xml-parse-from-string
-
-[![stable](http://badges.github.io/stability-badges/dist/stable.svg)](http://github.com/badges/stability-badges)
-
-A light browser wrapper around `DOMParser.parseFromString` for XML, with fallback for IE8 and other browsers.
-
-- attempts to use DOMParser with `"application/xml"`
-- falls back to `ActiveXObject('Microsoft.XMLDOM')`
-- then falls back to `createElement` / `innerHTML`  
-
-```js
-var parseXML = require('xml-parse-from-string')
-
-var str = '<root><foobar id="blah"></foobar></root>'
-var doc = parseXML(str)
-var tag = doc.getElementsByTagName('foobar')[0]
-
-console.log(tag.getAttribute('id')) // -> "blah"
-```
-
-Be wary of subtle differences between implementations, such as case-sensitivity in `attribute.nodeName`.
-
-PRs for Node version welcome.
-
-## Usage
-
-[![NPM](https://nodei.co/npm/xml-parse-from-string.png)](https://www.npmjs.com/package/xml-parse-from-string)
-
-#### `root = parse(str)`
-
-Parses the string as XML and returns the `root` element as a DOM element, so you can do operations similar to `document.getElementById`, `document.getElementsByTagName`, and so forth.
-
-## License
-
-MIT, see [LICENSE.md](http://github.com/Jam3/xml-parse-from-string/blob/master/LICENSE.md) for details.

package/node_modules/xmlbuilder/README.md

@@ -1,86 +0,0 @@
-# xmlbuilder-js
-
-An XML builder for [node.js](https://nodejs.org/) similar to
-[java-xmlbuilder](https://github.com/jmurty/java-xmlbuilder).
-
-[![License](http://img.shields.io/npm/l/xmlbuilder.svg?style=flat-square)](http://opensource.org/licenses/MIT)
-[![NPM Version](http://img.shields.io/npm/v/xmlbuilder.svg?style=flat-square)](https://npmjs.com/package/xmlbuilder)
-[![NPM Downloads](https://img.shields.io/npm/dm/xmlbuilder.svg?style=flat-square)](https://npmjs.com/package/xmlbuilder)
-
-[![Travis Build Status](http://img.shields.io/travis/oozcitak/xmlbuilder-js.svg?style=flat-square)](http://travis-ci.org/oozcitak/xmlbuilder-js)
-[![AppVeyor Build status](https://ci.appveyor.com/api/projects/status/bf7odb20hj77isry?svg=true)](https://ci.appveyor.com/project/oozcitak/xmlbuilder-js)
-[![Dev Dependency Status](http://img.shields.io/david/dev/oozcitak/xmlbuilder-js.svg?style=flat-square)](https://david-dm.org/oozcitak/xmlbuilder-js)
-[![Code Coverage](https://img.shields.io/coveralls/oozcitak/xmlbuilder-js.svg?style=flat-square)](https://coveralls.io/github/oozcitak/xmlbuilder-js)
-
-### Installation:
-
-``` sh
-npm install xmlbuilder
-```
-
-### Usage:
-
-``` js
-var builder = require('xmlbuilder');
-var xml = builder.create('root')
-  .ele('xmlbuilder')
-    .ele('repo', {'type': 'git'}, 'git://github.com/oozcitak/xmlbuilder-js.git')
-  .end({ pretty: true});
-
-console.log(xml);
-```
-
-will result in:
-
-``` xml
-<?xml version="1.0"?>
-<root>
-  <xmlbuilder>
-    <repo type="git">git://github.com/oozcitak/xmlbuilder-js.git</repo>
-  </xmlbuilder>
-</root>
-```
-
-It is also possible to convert objects into nodes:
-
-``` js
-builder.create({
-  root: {
-    xmlbuilder: {
-      repo: {
-        '@type': 'git', // attributes start with @
-        '#text': 'git://github.com/oozcitak/xmlbuilder-js.git' // text node
-      }
-    }
-  }
-});
-```
-
-If you need to do some processing:
-
-``` js
-var root = builder.create('squares');
-root.com('f(x) = x^2');
-for(var i = 1; i <= 5; i++)
-{
-  var item = root.ele('data');
-  item.att('x', i);
-  item.att('y', i * i);
-}
-```
-
-This will result in:
-
-``` xml
-<?xml version="1.0"?>
-<squares>
-  <!-- f(x) = x^2 -->
-  <data x="1" y="1"/>
-  <data x="2" y="4"/>
-  <data x="3" y="9"/>
-  <data x="4" y="16"/>
-  <data x="5" y="25"/>
-</squares>
-```
-
-See the [wiki](https://github.com/oozcitak/xmlbuilder-js/wiki) for details and [examples](https://github.com/oozcitak/xmlbuilder-js/wiki/Examples) for more complex examples.