@amazon/vinyl-util 1.0.0

package/dist/types/current/util/serialization/json.js

@@ -0,0 +1,79 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isPlainObject } from '../../util/object/object';
+/**
+ * Converts a dynamic value to a serializable value.
+ * The value must be either an object with a toJSON function, a primitive, or a plain object
+ * where all enumerable properties map to values supported by this function.
+ * Properties not enumerable will be omitted, properties not serializable will be converted
+ * to strings.
+ * - bigint -> value.toString
+ * - function -> [function <name>]
+ * - symbol -> [symbol <name>]
+ *
+ * Error instances have a special case where non-serializable errors will still have their
+ * name, message, and stack properties serialized.
+ *
+ * Note that this is not intended for use in serializing objects where all values are known;
+ * it's intended to cover the case of reporting or logging an unknown object that may or may not
+ * be serializable.
+ *
+ * @param value
+ */
+export function toJson(value) {
+    return toJsonInternal(value, new Set());
+}
+function toJsonInternal(value, visited) {
+    switch (typeof value) {
+        case 'object':
+            return objectToJsonInternal(value, visited);
+        case 'undefined':
+        case 'boolean':
+        case 'number':
+        case 'string':
+            return value;
+        case 'function':
+            return `[function ${value.name}]`;
+        case 'symbol':
+            return `[symbol ${value.toString().slice(7, -1)}]`;
+        case 'bigint':
+            return value.toString();
+    }
+}
+function objectToJsonInternal(value, visited) {
+    if (value == null)
+        return value;
+    if (visited.has(value))
+        return `<circular reference: ${String(value)}>`;
+    visited.add(value);
+    if ('toJSON' in value && typeof value.toJSON === 'function')
+        return value.toJSON();
+    if (value instanceof Set) {
+        return Array.from(value).map((e) => toJsonInternal(e, visited));
+    }
+    else if (Array.isArray(value)) {
+        return value.map((e) => toJsonInternal(e, visited));
+    }
+    else {
+        if (isPlainObject(value)) {
+            const o = {};
+            for (const key in value) {
+                o[key] = toJsonInternal(value[key], visited);
+            }
+            return o;
+        }
+        else if (value instanceof Error) {
+            // non-enumerable properties
+            return {
+                name: value.name,
+                message: value.message,
+                stack: value.stack,
+            };
+        }
+        else {
+            return value.toString();
+        }
+    }
+}

package/dist/types/current/util/serialization/primitives.d.ts

@@ -0,0 +1,24 @@
+import type { Maybe } from '../../util/type';
+/**
+ * Returns true if the given string is 'true' or '1'
+ *
+ * @param str
+ */
+export declare function parseBoolean(str: Maybe<string>): boolean;
+/**
+ * Returns the toString() value of the given object.
+ *
+ * @param value
+ */
+export declare function stringify(value: any): string;
+/**
+ * Parses a string into an integer.
+ * If the string is nullish, empty, or is not a finite number, returns null.
+ */
+export declare function parseIntSafe(str: Maybe<string>, radix?: number): number | null;
+/**
+ * Parses a string into a number.
+ * If the string is nullish, empty, or is not a finite number, returns null.
+ */
+export declare function parseFloatSafe(str: Maybe<string>): number | null;
+//# sourceMappingURL=primitives.d.ts.map

package/dist/types/current/util/serialization/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../../../../src/util/serialization/primitives.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,OAAO,CAExD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,CAI5C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CACxB,GAAG,EAAE,KAAK,CAAC,MAAM,CAAC,EAClB,KAAK,CAAC,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CAKf;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,CAKhE"}

package/dist/types/current/util/serialization/primitives.js

@@ -0,0 +1,48 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Returns true if the given string is 'true' or '1'
+ *
+ * @param str
+ */
+export function parseBoolean(str) {
+    return str === 'true' || str === '1';
+}
+/**
+ * Returns the toString() value of the given object.
+ *
+ * @param value
+ */
+export function stringify(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    return value.toString();
+}
+/**
+ * Parses a string into an integer.
+ * If the string is nullish, empty, or is not a finite number, returns null.
+ */
+export function parseIntSafe(str, radix) {
+    if (!str)
+        return null;
+    const value = parseInt(str, radix);
+    if (!Number.isFinite(value))
+        return null;
+    return value;
+}
+/**
+ * Parses a string into a number.
+ * If the string is nullish, empty, or is not a finite number, returns null.
+ */
+export function parseFloatSafe(str) {
+    if (!str)
+        return null;
+    const value = parseFloat(str);
+    if (!Number.isFinite(value))
+        return null;
+    return value;
+}

package/dist/types/current/util/serialization/stringifyForPrint.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Stringifies a value suitable for human-readable messages.
+ *
+ * The value is first run through {@link toJson} which makes it safe for serialization.
+ * (Circular references will become strings, and toJSON serializers will be respected)
+ * The safe json is then stringified, using a JSON.stringify replacer that preserves
+ * representations for NaN, Infinity, undefined, and Symbol.
+ *
+ * @param value Any value.
+ * @param maxLength If provided, will truncate the final string.
+ * @param indicator The truncation indicator.
+ */
+export declare function stringifyForPrint(value: any, maxLength?: number, indicator?: string): string;
+//# sourceMappingURL=stringifyForPrint.d.ts.map

package/dist/types/current/util/serialization/stringifyForPrint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringifyForPrint.d.ts","sourceRoot":"","sources":["../../../../../src/util/serialization/stringifyForPrint.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC7B,KAAK,EAAE,GAAG,EACV,SAAS,CAAC,EAAE,MAAM,EAClB,SAAS,SAAM,GAChB,MAAM,CAwBR"}

package/dist/types/current/util/serialization/stringifyForPrint.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { toJson } from './json';
+import { truncate } from '../../util/string/string';
+/**
+ * Stringifies a value suitable for human-readable messages.
+ *
+ * The value is first run through {@link toJson} which makes it safe for serialization.
+ * (Circular references will become strings, and toJSON serializers will be respected)
+ * The safe json is then stringified, using a JSON.stringify replacer that preserves
+ * representations for NaN, Infinity, undefined, and Symbol.
+ *
+ * @param value Any value.
+ * @param maxLength If provided, will truncate the final string.
+ * @param indicator The truncation indicator.
+ */
+export function stringifyForPrint(value, maxLength, indicator = '…') {
+    // Preserve Symbol, function, and undefined, NaN, and +/- Infinity
+    let str = JSON.stringify(toJson(value), (_, value) => {
+        const type = typeof value;
+        if (['undefined'].includes(type)) {
+            return `{{${String(value)}}}`;
+        }
+        if (type === 'number') {
+            if (Number.isNaN(value) || !Number.isFinite(value))
+                return `{{${value.toString()}}}`;
+        }
+        return value;
+    }, '  ');
+    // Replace templated
+    str = str.replace(/("\{\{.*}}")/g, (_, s) => {
+        return s.substring(3, s.length - 3);
+    });
+    if (maxLength)
+        str = truncate(str, maxLength, indicator);
+    return str;
+}

package/dist/types/current/util/set/set.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns the union of two sets. That is, the unique elements of A and B.
+ *
+ * @param a
+ * @param b
+ * @return Returns a new Set `A ∪ B`
+ */
+export declare function union<T, U>(a: ReadonlySet<T>, b: ReadonlySet<U>): Set<T | U>;
+/**
+ * Returns the set difference of A and B. That is, the elements of A that are not in B.
+ *
+ * @param a
+ * @param b
+ * @return Returns a new Set that is `A \ B`
+ */
+export declare function diff<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): Set<T>;
+//# sourceMappingURL=set.d.ts.map

package/dist/types/current/util/set/set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../../../../src/util/set/set.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAE5E;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAMpE"}

package/dist/types/current/util/set/set.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Returns the union of two sets. That is, the unique elements of A and B.
+ *
+ * @param a
+ * @param b
+ * @return Returns a new Set `A ∪ B`
+ */
+export function union(a, b) {
+    return new Set([...a, ...b]);
+}
+/**
+ * Returns the set difference of A and B. That is, the elements of A that are not in B.
+ *
+ * @param a
+ * @param b
+ * @return Returns a new Set that is `A \ B`
+ */
+export function diff(a, b) {
+    const out = new Set();
+    a.forEach((e) => {
+        if (!b.has(e))
+            out.add(e);
+    });
+    return out;
+}

package/dist/types/current/util/string/StringReader.d.ts

@@ -0,0 +1,149 @@
+import { ReportableError } from '../../error/ReportableError';
+import type { ParseError } from '../../util/serialization/ParseError';
+import type { Json } from '../../util/serialization/json';
+/**
+ * A cursor on a string that allows for fast, naive parsing.
+ */
+export declare class StringReader {
+    data: string;
+    /**
+     * @param data The string to read.
+     */
+    constructor(data: string);
+    /**
+     * The current cursor.
+     * This should always be between the range 0 and `data.length`
+     */
+    position: number;
+    /**
+     * Returns true if the current {@link position} is less than the source data's length.
+     */
+    hasNext(): boolean;
+    /**
+     * Returns the number of characters remaining to be read.
+     */
+    get remaining(): number;
+    /**
+     * Returns the length of {@link data}.
+     */
+    get length(): number;
+    /**
+     * Throws a {@link StringParseError} where the location uses {@link printStringPosition} to
+     * show a friendly message indicating the current position.
+     *
+     * @param message
+     * @param offset The offset to add to the current position.
+     */
+    err(message: string, offset?: number): never;
+    /**
+     * Reads and returns the character code at the current position.
+     * To read the next character without advancing the cursor, use {@link peek}
+     *
+     * Note:
+     * This method has no bounds checking; if {@link position} is greater than or equal to
+     * `str.length` then NaN will be returned and {@link position} will still be incremented.
+     *
+     * @see String.charCodeAt
+     */
+    next(): number;
+    /**
+     * Reads characters until the predicate returns false or the data length has been reached.
+     *
+     * @param predicate Given the char code at the cursor index, returns true if the character
+     * should be included in the substring result.
+     * @returns number The start position.
+     */
+    while(predicate: (charCode: number) => boolean): number;
+    /**
+     * Reads characters until the predicate returns true or the string length has been reached.
+     *
+     * @param predicate
+     * @returns number Returns the start index.
+     */
+    until(predicate: (charCode: number) => boolean): number;
+    /**
+     * Reads characters until the given character has been found or the string length has been
+     * reached.
+     *
+     * @param charCode
+     * @return number Returns the start index.
+     */
+    untilChar(charCode: number): number;
+    /**
+     * Reads characters until the given string has been found or the string length has been
+     * reached.
+     *
+     * @param string The string to match
+     * @return number Returns the start index.
+     */
+    untilString(string: string): number;
+    /**
+     * The same as {@link while} except returns the read substring as a result.
+     */
+    substringWhile(predicate: (charCode: number) => boolean): string;
+    /**
+     * The same as {@link until} except returns the read substring as a result.
+     */
+    substringUntil(predicate: (charCode: number) => boolean): string;
+    /**
+     * The same as {@link untilChar} except returns the read substring as a result.
+     */
+    substringUntilChar(charCode: number): string;
+    /**
+     * Reads the substring from the current index with the given length.
+     *
+     * @param length
+     */
+    substr(length: number): string;
+    /**
+     * Reads the expected string from the current position.
+     * If the read string doesn't match the given string, a {@link StringParseError} is thrown.
+     *
+     * @param str The string required to match at the current position.
+     * @param ignoreCase If true, the comparison will be case-insensitive.
+     */
+    read(str: string, ignoreCase?: boolean): string;
+    /**
+     * Reads the expected char code from the current position.
+     * If the read character doesn't match the given character, a {@link StringParseError} is
+     * thrown.
+     *
+     * @param charCode The character code required to match at the current position.
+     */
+    readChar(charCode: number): number;
+    /**
+     * Returns the character at the current position without advancing the cursor.
+     *
+     * Note:
+     * This method has no bounds checking; if {@link position} is greater than or equal to
+     * `str.length` then `NaN` will be returned.
+     *
+     * @see String.charCodeAt
+     */
+    get peek(): number;
+    /**
+     * Reads through all whitespace characters, returning the starting index.
+     */
+    white(): number;
+    /**
+     * If {@link peek} equals the given character code, returns true and advances the index by
+     * one.
+     *
+     * @param charCode
+     */
+    charIf(charCode: number): boolean;
+    /**
+     * If the given string matches the substring at the current position, returns true and advances
+     * the index by the string's length.
+     */
+    stringIf(string: string, ignoreCase?: boolean): boolean;
+}
+export declare class StringParseError extends ReportableError implements ParseError {
+    readonly position: number;
+    readonly reason: string;
+    get [Symbol.toStringTag](): string;
+    readonly location: string;
+    constructor(str: string, position: number, reason: string);
+    toJSON(): Json;
+}
+//# sourceMappingURL=StringReader.d.ts.map

package/dist/types/current/util/string/StringReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringReader.d.ts","sourceRoot":"","sources":["../../../../../src/util/string/StringReader.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAGjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAA;AAErD;;GAEG;AACH,qBAAa,YAAY;IAIF,IAAI,EAAE,MAAM;IAH/B;;OAEG;gBACgB,IAAI,EAAE,MAAM;IAE/B;;;OAGG;IACH,QAAQ,SAAI;IAEZ;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;OAMG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,KAAK;IAIvC;;;;;;;;;OASG;IACH,IAAI,IAAI,MAAM;IAId;;;;;;OAMG;IACH,KAAK,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,GAAG,MAAM;IASvD;;;;;OAKG;IACH,KAAK,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,GAAG,MAAM;IAIvD;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAInC;;;;;;OAMG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAOnC;;OAEG;IACH,cAAc,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,GAAG,MAAM;IAIhE;;OAEG;IACH,cAAc,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,GAAG,MAAM;IAIhE;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAI5C;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAM9B;;;;;;OAMG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,UAAQ,GAAG,MAAM;IAO7C;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAUlC;;;;;;;;OAQG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,KAAK,IAAI,MAAM;IAIf;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IASjC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,UAAQ,GAAG,OAAO;CAUxD;AAMD,qBAAa,gBAAiB,SAAQ,eAAgB,YAAW,UAAU;IASnE,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM;IAT3B,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;gBAGrB,GAAG,EAAE,MAAM,EACF,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM;IAW3B,MAAM,IAAI,IAAI;CAQjB"}

package/dist/types/current/util/string/StringReader.js

@@ -0,0 +1,242 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorOrigin } from '../../error/ErrorOrigin';
+import { ReportableError } from '../../error/ReportableError';
+import { printStringPosition } from '../../util/serialization/ParseError';
+import { eqStr, isWhitespaceChar } from './string';
+/**
+ * A cursor on a string that allows for fast, naive parsing.
+ */
+export class StringReader {
+    data;
+    /**
+     * @param data The string to read.
+     */
+    constructor(data) {
+        this.data = data;
+    }
+    /**
+     * The current cursor.
+     * This should always be between the range 0 and `data.length`
+     */
+    position = 0;
+    /**
+     * Returns true if the current {@link position} is less than the source data's length.
+     */
+    hasNext() {
+        return this.position < this.data.length;
+    }
+    /**
+     * Returns the number of characters remaining to be read.
+     */
+    get remaining() {
+        return this.data.length - this.position;
+    }
+    /**
+     * Returns the length of {@link data}.
+     */
+    get length() {
+        return this.data.length;
+    }
+    /**
+     * Throws a {@link StringParseError} where the location uses {@link printStringPosition} to
+     * show a friendly message indicating the current position.
+     *
+     * @param message
+     * @param offset The offset to add to the current position.
+     */
+    err(message, offset = 0) {
+        throw new StringParseError(this.data, this.position + offset, message);
+    }
+    /**
+     * Reads and returns the character code at the current position.
+     * To read the next character without advancing the cursor, use {@link peek}
+     *
+     * Note:
+     * This method has no bounds checking; if {@link position} is greater than or equal to
+     * `str.length` then NaN will be returned and {@link position} will still be incremented.
+     *
+     * @see String.charCodeAt
+     */
+    next() {
+        return this.data.charCodeAt(this.position++);
+    }
+    /**
+     * Reads characters until the predicate returns false or the data length has been reached.
+     *
+     * @param predicate Given the char code at the cursor index, returns true if the character
+     * should be included in the substring result.
+     * @returns number The start position.
+     */
+    while(predicate) {
+        const start = this.position;
+        let i = start;
+        const n = this.data.length;
+        while (i < n && predicate(this.data.charCodeAt(i)))
+            i++;
+        this.position = i;
+        return start;
+    }
+    /**
+     * Reads characters until the predicate returns true or the string length has been reached.
+     *
+     * @param predicate
+     * @returns number Returns the start index.
+     */
+    until(predicate) {
+        return this.while((charCode) => !predicate(charCode));
+    }
+    /**
+     * Reads characters until the given character has been found or the string length has been
+     * reached.
+     *
+     * @param charCode
+     * @return number Returns the start index.
+     */
+    untilChar(charCode) {
+        return this.until((cc) => cc === charCode);
+    }
+    /**
+     * Reads characters until the given string has been found or the string length has been
+     * reached.
+     *
+     * @param string The string to match
+     * @return number Returns the start index.
+     */
+    untilString(string) {
+        const start = this.position;
+        const index = this.data.indexOf(string, this.position);
+        this.position = index === -1 ? this.data.length : index;
+        return start;
+    }
+    /**
+     * The same as {@link while} except returns the read substring as a result.
+     */
+    substringWhile(predicate) {
+        return this.data.substring(this.while(predicate), this.position);
+    }
+    /**
+     * The same as {@link until} except returns the read substring as a result.
+     */
+    substringUntil(predicate) {
+        return this.substringWhile((charCode) => !predicate(charCode));
+    }
+    /**
+     * The same as {@link untilChar} except returns the read substring as a result.
+     */
+    substringUntilChar(charCode) {
+        return this.substringWhile((iCharCode) => charCode !== iCharCode);
+    }
+    /**
+     * Reads the substring from the current index with the given length.
+     *
+     * @param length
+     */
+    substr(length) {
+        const sub = this.data.substring(this.position, this.position + length);
+        this.position += sub.length;
+        return sub;
+    }
+    /**
+     * Reads the expected string from the current position.
+     * If the read string doesn't match the given string, a {@link StringParseError} is thrown.
+     *
+     * @param str The string required to match at the current position.
+     * @param ignoreCase If true, the comparison will be case-insensitive.
+     */
+    read(str, ignoreCase = false) {
+        const actual = this.substr(str.length);
+        if (!eqStr(actual, str, ignoreCase))
+            this.err(`Expected '${str}', actual: '${actual}'`);
+        return actual;
+    }
+    /**
+     * Reads the expected char code from the current position.
+     * If the read character doesn't match the given character, a {@link StringParseError} is
+     * thrown.
+     *
+     * @param charCode The character code required to match at the current position.
+     */
+    readChar(charCode) {
+        const actual = this.next();
+        if (actual !== charCode)
+            this.err(`Expected '${String.fromCharCode(charCode)}', ` +
+                `actual: '${String.fromCharCode(actual)}'`);
+        return actual;
+    }
+    /**
+     * Returns the character at the current position without advancing the cursor.
+     *
+     * Note:
+     * This method has no bounds checking; if {@link position} is greater than or equal to
+     * `str.length` then `NaN` will be returned.
+     *
+     * @see String.charCodeAt
+     */
+    get peek() {
+        return this.data.charCodeAt(this.position);
+    }
+    /**
+     * Reads through all whitespace characters, returning the starting index.
+     */
+    white() {
+        return this.while(isWhitespaceChar);
+    }
+    /**
+     * If {@link peek} equals the given character code, returns true and advances the index by
+     * one.
+     *
+     * @param charCode
+     */
+    charIf(charCode) {
+        if (this.peek === charCode) {
+            this.next();
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * If the given string matches the substring at the current position, returns true and advances
+     * the index by the string's length.
+     */
+    stringIf(string, ignoreCase = false) {
+        if (this.remaining < string.length)
+            return false;
+        const substr = this.data.substring(this.position, this.position + string.length);
+        const match = eqStr(substr, string, ignoreCase);
+        if (match)
+            this.position += string.length;
+        return match;
+    }
+}
+const locale = {
+    messageSeparator: ', at: \n',
+};
+export class StringParseError extends ReportableError {
+    position;
+    reason;
+    get [Symbol.toStringTag]() {
+        return 'StringParseError';
+    }
+    location;
+    constructor(str, position, reason) {
+        const location = printStringPosition(str, position);
+        super(`${reason}${locale.messageSeparator}${location}`, ErrorOrigin.PARSING);
+        this.position = position;
+        this.reason = reason;
+        this.location = location;
+        Object.setPrototypeOf(this, StringParseError.prototype);
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            position: this.position,
+            location: this.location,
+            reason: this.reason,
+        };
+    }
+}