@formatjs/icu-messageformat-parser 2.11.4 → 3.0.0

package/lib/error.d.ts

@@ -1,68 +0,0 @@
-import { Location } from './types';
-export interface ParserError {
-    kind: ErrorKind;
-    message: string;
-    location: Location;
-}
-export declare enum ErrorKind {
-    /** Argument is unclosed (e.g. `{0`) */
-    EXPECT_ARGUMENT_CLOSING_BRACE = 1,
-    /** Argument is empty (e.g. `{}`). */
-    EMPTY_ARGUMENT = 2,
-    /** Argument is malformed (e.g. `{foo!}``) */
-    MALFORMED_ARGUMENT = 3,
-    /** Expect an argument type (e.g. `{foo,}`) */
-    EXPECT_ARGUMENT_TYPE = 4,
-    /** Unsupported argument type (e.g. `{foo,foo}`) */
-    INVALID_ARGUMENT_TYPE = 5,
-    /** Expect an argument style (e.g. `{foo, number, }`) */
-    EXPECT_ARGUMENT_STYLE = 6,
-    /** The number skeleton is invalid. */
-    INVALID_NUMBER_SKELETON = 7,
-    /** The date time skeleton is invalid. */
-    INVALID_DATE_TIME_SKELETON = 8,
-    /** Exepct a number skeleton following the `::` (e.g. `{foo, number, ::}`) */
-    EXPECT_NUMBER_SKELETON = 9,
-    /** Exepct a date time skeleton following the `::` (e.g. `{foo, date, ::}`) */
-    EXPECT_DATE_TIME_SKELETON = 10,
-    /** Unmatched apostrophes in the argument style (e.g. `{foo, number, 'test`) */
-    UNCLOSED_QUOTE_IN_ARGUMENT_STYLE = 11,
-    /** Missing select argument options (e.g. `{foo, select}`) */
-    EXPECT_SELECT_ARGUMENT_OPTIONS = 12,
-    /** Expecting an offset value in `plural` or `selectordinal` argument (e.g `{foo, plural, offset}`) */
-    EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE = 13,
-    /** Offset value in `plural` or `selectordinal` is invalid (e.g. `{foo, plural, offset: x}`) */
-    INVALID_PLURAL_ARGUMENT_OFFSET_VALUE = 14,
-    /** Expecting a selector in `select` argument (e.g `{foo, select}`) */
-    EXPECT_SELECT_ARGUMENT_SELECTOR = 15,
-    /** Expecting a selector in `plural` or `selectordinal` argument (e.g `{foo, plural}`) */
-    EXPECT_PLURAL_ARGUMENT_SELECTOR = 16,
-    /** Expecting a message fragment after the `select` selector (e.g. `{foo, select, apple}`) */
-    EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT = 17,
-    /**
-     * Expecting a message fragment after the `plural` or `selectordinal` selector
-     * (e.g. `{foo, plural, one}`)
-     */
-    EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT = 18,
-    /** Selector in `plural` or `selectordinal` is malformed (e.g. `{foo, plural, =x {#}}`) */
-    INVALID_PLURAL_ARGUMENT_SELECTOR = 19,
-    /**
-     * Duplicate selectors in `plural` or `selectordinal` argument.
-     * (e.g. {foo, plural, one {#} one {#}})
-     */
-    DUPLICATE_PLURAL_ARGUMENT_SELECTOR = 20,
-    /** Duplicate selectors in `select` argument.
-     * (e.g. {foo, select, apple {apple} apple {apple}})
-     */
-    DUPLICATE_SELECT_ARGUMENT_SELECTOR = 21,
-    /** Plural or select argument option must have `other` clause. */
-    MISSING_OTHER_CLAUSE = 22,
-    /** The tag is malformed. (e.g. `<bold!>foo</bold!>) */
-    INVALID_TAG = 23,
-    /** The tag name is invalid. (e.g. `<123>foo</123>`) */
-    INVALID_TAG_NAME = 25,
-    /** The closing tag does not match the opening tag. (e.g. `<bold>foo</italic>`) */
-    UNMATCHED_CLOSING_TAG = 26,
-    /** The opening tag has unmatched closing tag. (e.g. `<bold>foo`) */
-    UNCLOSED_TAG = 27
-}

package/lib/error.js

@@ -1,63 +0,0 @@
-export var ErrorKind;
-(function (ErrorKind) {
-    /** Argument is unclosed (e.g. `{0`) */
-    ErrorKind[ErrorKind["EXPECT_ARGUMENT_CLOSING_BRACE"] = 1] = "EXPECT_ARGUMENT_CLOSING_BRACE";
-    /** Argument is empty (e.g. `{}`). */
-    ErrorKind[ErrorKind["EMPTY_ARGUMENT"] = 2] = "EMPTY_ARGUMENT";
-    /** Argument is malformed (e.g. `{foo!}``) */
-    ErrorKind[ErrorKind["MALFORMED_ARGUMENT"] = 3] = "MALFORMED_ARGUMENT";
-    /** Expect an argument type (e.g. `{foo,}`) */
-    ErrorKind[ErrorKind["EXPECT_ARGUMENT_TYPE"] = 4] = "EXPECT_ARGUMENT_TYPE";
-    /** Unsupported argument type (e.g. `{foo,foo}`) */
-    ErrorKind[ErrorKind["INVALID_ARGUMENT_TYPE"] = 5] = "INVALID_ARGUMENT_TYPE";
-    /** Expect an argument style (e.g. `{foo, number, }`) */
-    ErrorKind[ErrorKind["EXPECT_ARGUMENT_STYLE"] = 6] = "EXPECT_ARGUMENT_STYLE";
-    /** The number skeleton is invalid. */
-    ErrorKind[ErrorKind["INVALID_NUMBER_SKELETON"] = 7] = "INVALID_NUMBER_SKELETON";
-    /** The date time skeleton is invalid. */
-    ErrorKind[ErrorKind["INVALID_DATE_TIME_SKELETON"] = 8] = "INVALID_DATE_TIME_SKELETON";
-    /** Exepct a number skeleton following the `::` (e.g. `{foo, number, ::}`) */
-    ErrorKind[ErrorKind["EXPECT_NUMBER_SKELETON"] = 9] = "EXPECT_NUMBER_SKELETON";
-    /** Exepct a date time skeleton following the `::` (e.g. `{foo, date, ::}`) */
-    ErrorKind[ErrorKind["EXPECT_DATE_TIME_SKELETON"] = 10] = "EXPECT_DATE_TIME_SKELETON";
-    /** Unmatched apostrophes in the argument style (e.g. `{foo, number, 'test`) */
-    ErrorKind[ErrorKind["UNCLOSED_QUOTE_IN_ARGUMENT_STYLE"] = 11] = "UNCLOSED_QUOTE_IN_ARGUMENT_STYLE";
-    /** Missing select argument options (e.g. `{foo, select}`) */
-    ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_OPTIONS"] = 12] = "EXPECT_SELECT_ARGUMENT_OPTIONS";
-    /** Expecting an offset value in `plural` or `selectordinal` argument (e.g `{foo, plural, offset}`) */
-    ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE"] = 13] = "EXPECT_PLURAL_ARGUMENT_OFFSET_VALUE";
-    /** Offset value in `plural` or `selectordinal` is invalid (e.g. `{foo, plural, offset: x}`) */
-    ErrorKind[ErrorKind["INVALID_PLURAL_ARGUMENT_OFFSET_VALUE"] = 14] = "INVALID_PLURAL_ARGUMENT_OFFSET_VALUE";
-    /** Expecting a selector in `select` argument (e.g `{foo, select}`) */
-    ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_SELECTOR"] = 15] = "EXPECT_SELECT_ARGUMENT_SELECTOR";
-    /** Expecting a selector in `plural` or `selectordinal` argument (e.g `{foo, plural}`) */
-    ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_SELECTOR"] = 16] = "EXPECT_PLURAL_ARGUMENT_SELECTOR";
-    /** Expecting a message fragment after the `select` selector (e.g. `{foo, select, apple}`) */
-    ErrorKind[ErrorKind["EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT"] = 17] = "EXPECT_SELECT_ARGUMENT_SELECTOR_FRAGMENT";
-    /**
-     * Expecting a message fragment after the `plural` or `selectordinal` selector
-     * (e.g. `{foo, plural, one}`)
-     */
-    ErrorKind[ErrorKind["EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT"] = 18] = "EXPECT_PLURAL_ARGUMENT_SELECTOR_FRAGMENT";
-    /** Selector in `plural` or `selectordinal` is malformed (e.g. `{foo, plural, =x {#}}`) */
-    ErrorKind[ErrorKind["INVALID_PLURAL_ARGUMENT_SELECTOR"] = 19] = "INVALID_PLURAL_ARGUMENT_SELECTOR";
-    /**
-     * Duplicate selectors in `plural` or `selectordinal` argument.
-     * (e.g. {foo, plural, one {#} one {#}})
-     */
-    ErrorKind[ErrorKind["DUPLICATE_PLURAL_ARGUMENT_SELECTOR"] = 20] = "DUPLICATE_PLURAL_ARGUMENT_SELECTOR";
-    /** Duplicate selectors in `select` argument.
-     * (e.g. {foo, select, apple {apple} apple {apple}})
-     */
-    ErrorKind[ErrorKind["DUPLICATE_SELECT_ARGUMENT_SELECTOR"] = 21] = "DUPLICATE_SELECT_ARGUMENT_SELECTOR";
-    /** Plural or select argument option must have `other` clause. */
-    ErrorKind[ErrorKind["MISSING_OTHER_CLAUSE"] = 22] = "MISSING_OTHER_CLAUSE";
-    /** The tag is malformed. (e.g. `<bold!>foo</bold!>) */
-    ErrorKind[ErrorKind["INVALID_TAG"] = 23] = "INVALID_TAG";
-    /** The tag name is invalid. (e.g. `<123>foo</123>`) */
-    ErrorKind[ErrorKind["INVALID_TAG_NAME"] = 25] = "INVALID_TAG_NAME";
-    /** The closing tag does not match the opening tag. (e.g. `<bold>foo</italic>`) */
-    ErrorKind[ErrorKind["UNMATCHED_CLOSING_TAG"] = 26] = "UNMATCHED_CLOSING_TAG";
-    /** The opening tag has unmatched closing tag. (e.g. `<bold>foo`) */
-    ErrorKind[ErrorKind["UNCLOSED_TAG"] = 27] = "UNCLOSED_TAG";
-})(ErrorKind || (ErrorKind = {}));

package/lib/index.d.ts

@@ -1,7 +0,0 @@
-import { Parser, ParserOptions } from './parser';
-import { MessageFormatElement } from './types';
-export declare function parse(message: string, opts?: ParserOptions): MessageFormatElement[];
-export * from './types';
-export type { ParserOptions };
-export declare const _Parser: typeof Parser;
-export { isStructurallySame } from './manipulator';

package/lib/index.js

@@ -1,46 +0,0 @@
-import { __assign } from "tslib";
-import { ErrorKind } from './error';
-import { Parser } from './parser';
-import { isDateElement, isDateTimeSkeleton, isNumberElement, isNumberSkeleton, isPluralElement, isSelectElement, isTagElement, isTimeElement, } from './types';
-function pruneLocation(els) {
-    els.forEach(function (el) {
-        delete el.location;
-        if (isSelectElement(el) || isPluralElement(el)) {
-            for (var k in el.options) {
-                delete el.options[k].location;
-                pruneLocation(el.options[k].value);
-            }
-        }
-        else if (isNumberElement(el) && isNumberSkeleton(el.style)) {
-            delete el.style.location;
-        }
-        else if ((isDateElement(el) || isTimeElement(el)) &&
-            isDateTimeSkeleton(el.style)) {
-            delete el.style.location;
-        }
-        else if (isTagElement(el)) {
-            pruneLocation(el.children);
-        }
-    });
-}
-export function parse(message, opts) {
-    if (opts === void 0) { opts = {}; }
-    opts = __assign({ shouldParseSkeletons: true, requiresOtherClause: true }, opts);
-    var result = new Parser(message, opts).parse();
-    if (result.err) {
-        var error = SyntaxError(ErrorKind[result.err.kind]);
-        // @ts-expect-error Assign to error object
-        error.location = result.err.location;
-        // @ts-expect-error Assign to error object
-        error.originalMessage = result.err.message;
-        throw error;
-    }
-    if (!(opts === null || opts === void 0 ? void 0 : opts.captureLocation)) {
-        pruneLocation(result.val);
-    }
-    return result.val;
-}
-export * from './types';
-// only for testing
-export var _Parser = Parser;
-export { isStructurallySame } from './manipulator';

package/lib/manipulator.d.ts

@@ -1,26 +0,0 @@
-import { MessageFormatElement } from './types';
-/**
- * Hoist all selectors to the beginning of the AST & flatten the
- * resulting options. E.g:
- * "I have {count, plural, one{a dog} other{many dogs}}"
- * becomes "{count, plural, one{I have a dog} other{I have many dogs}}".
- * If there are multiple selectors, the order of which one is hoisted 1st
- * is non-deterministic.
- * The goal is to provide as many full sentences as possible since fragmented
- * sentences are not translator-friendly
- * @param ast AST
- */
-export declare function hoistSelectors(ast: MessageFormatElement[]): MessageFormatElement[];
-interface IsStructurallySameResult {
-    error?: Error;
-    success: boolean;
-}
-/**
- * Check if 2 ASTs are structurally the same. This primarily means that
- * they have the same variables with the same type
- * @param a
- * @param b
- * @returns
- */
-export declare function isStructurallySame(a: MessageFormatElement[], b: MessageFormatElement[]): IsStructurallySameResult;
-export {};

package/lib/manipulator.js

@@ -1,135 +0,0 @@
-import { __spreadArray } from "tslib";
-import { isArgumentElement, isDateElement, isNumberElement, isPluralElement, isSelectElement, isTagElement, isTimeElement, TYPE, } from './types';
-function cloneDeep(obj) {
-    if (Array.isArray(obj)) {
-        // @ts-expect-error meh
-        return __spreadArray([], obj.map(cloneDeep), true);
-    }
-    if (obj !== null && typeof obj === 'object') {
-        // @ts-expect-error meh
-        return Object.keys(obj).reduce(function (cloned, k) {
-            // @ts-expect-error meh
-            cloned[k] = cloneDeep(obj[k]);
-            return cloned;
-        }, {});
-    }
-    return obj;
-}
-function hoistPluralOrSelectElement(ast, el, positionToInject) {
-    // pull this out of the ast and move it to the top
-    var cloned = cloneDeep(el);
-    var options = cloned.options;
-    cloned.options = Object.keys(options).reduce(function (all, k) {
-        var newValue = hoistSelectors(__spreadArray(__spreadArray(__spreadArray([], ast.slice(0, positionToInject), true), options[k].value, true), ast.slice(positionToInject + 1), true));
-        all[k] = {
-            value: newValue,
-        };
-        return all;
-    }, {});
-    return cloned;
-}
-function isPluralOrSelectElement(el) {
-    return isPluralElement(el) || isSelectElement(el);
-}
-function findPluralOrSelectElement(ast) {
-    return !!ast.find(function (el) {
-        if (isPluralOrSelectElement(el)) {
-            return true;
-        }
-        if (isTagElement(el)) {
-            return findPluralOrSelectElement(el.children);
-        }
-        return false;
-    });
-}
-/**
- * Hoist all selectors to the beginning of the AST & flatten the
- * resulting options. E.g:
- * "I have {count, plural, one{a dog} other{many dogs}}"
- * becomes "{count, plural, one{I have a dog} other{I have many dogs}}".
- * If there are multiple selectors, the order of which one is hoisted 1st
- * is non-deterministic.
- * The goal is to provide as many full sentences as possible since fragmented
- * sentences are not translator-friendly
- * @param ast AST
- */
-export function hoistSelectors(ast) {
-    for (var i = 0; i < ast.length; i++) {
-        var el = ast[i];
-        if (isPluralOrSelectElement(el)) {
-            return [hoistPluralOrSelectElement(ast, el, i)];
-        }
-        if (isTagElement(el) && findPluralOrSelectElement([el])) {
-            throw new Error('Cannot hoist plural/select within a tag element. Please put the tag element inside each plural/select option');
-        }
-    }
-    return ast;
-}
-/**
- * Collect all variables in an AST to Record<string, TYPE>
- * @param ast AST to collect variables from
- * @param vars Record of variable name to variable type
- */
-function collectVariables(ast, vars) {
-    if (vars === void 0) { vars = new Map(); }
-    ast.forEach(function (el) {
-        if (isArgumentElement(el) ||
-            isDateElement(el) ||
-            isTimeElement(el) ||
-            isNumberElement(el)) {
-            if (el.value in vars && vars.get(el.value) !== el.type) {
-                throw new Error("Variable ".concat(el.value, " has conflicting types"));
-            }
-            vars.set(el.value, el.type);
-        }
-        if (isPluralElement(el) || isSelectElement(el)) {
-            vars.set(el.value, el.type);
-            Object.keys(el.options).forEach(function (k) {
-                collectVariables(el.options[k].value, vars);
-            });
-        }
-        if (isTagElement(el)) {
-            vars.set(el.value, el.type);
-            collectVariables(el.children, vars);
-        }
-    });
-}
-/**
- * Check if 2 ASTs are structurally the same. This primarily means that
- * they have the same variables with the same type
- * @param a
- * @param b
- * @returns
- */
-export function isStructurallySame(a, b) {
-    var aVars = new Map();
-    var bVars = new Map();
-    collectVariables(a, aVars);
-    collectVariables(b, bVars);
-    if (aVars.size !== bVars.size) {
-        return {
-            success: false,
-            error: new Error("Different number of variables: [".concat(Array.from(aVars.keys()).join(', '), "] vs [").concat(Array.from(bVars.keys()).join(', '), "]")),
-        };
-    }
-    return Array.from(aVars.entries()).reduce(function (result, _a) {
-        var key = _a[0], type = _a[1];
-        if (!result.success) {
-            return result;
-        }
-        var bType = bVars.get(key);
-        if (bType == null) {
-            return {
-                success: false,
-                error: new Error("Missing variable ".concat(key, " in message")),
-            };
-        }
-        if (bType !== type) {
-            return {
-                success: false,
-                error: new Error("Variable ".concat(key, " has conflicting types: ").concat(TYPE[type], " vs ").concat(TYPE[bType])),
-            };
-        }
-        return result;
-    }, { success: true });
-}

package/lib/no-parser.d.ts

@@ -1,4 +0,0 @@
-export declare function parse(): void;
-export * from './types';
-export declare const _Parser: undefined;
-export { isStructurallySame } from './manipulator';

package/lib/no-parser.js

@@ -1,6 +0,0 @@
-export function parse() {
-    throw new Error("You're trying to format an uncompiled message with react-intl without parser, please import from 'react-intl' instead");
-}
-export * from './types';
-export var _Parser = undefined;
-export { isStructurallySame } from './manipulator';

package/lib/parser.d.ts

@@ -1,147 +0,0 @@
-import { ParserError } from './error';
-import { MessageFormatElement } from './types';
-export interface Position {
-    /** Offset in terms of UTF-16 *code unit*. */
-    offset: number;
-    line: number;
-    /** Column offset in terms of unicode *code point*. */
-    column: number;
-}
-export interface ParserOptions {
-    /**
-     * Whether to treat HTML/XML tags as string literal
-     * instead of parsing them as tag token.
-     * When this is false we only allow simple tags without
-     * any attributes
-     */
-    ignoreTag?: boolean;
-    /**
-     * Should `select`, `selectordinal`, and `plural` arguments always include
-     * the `other` case clause.
-     */
-    requiresOtherClause?: boolean;
-    /**
-     * Whether to parse number/datetime skeleton
-     * into Intl.NumberFormatOptions and Intl.DateTimeFormatOptions, respectively.
-     */
-    shouldParseSkeletons?: boolean;
-    /**
-     * Capture location info in AST
-     * Default is false
-     */
-    captureLocation?: boolean;
-    /**
-     * Instance of Intl.Locale to resolve locale-dependent skeleton
-     */
-    locale?: Intl.Locale;
-}
-export type Result<T, E> = {
-    val: T;
-    err: null;
-} | {
-    val: null;
-    err: E;
-};
-export declare class Parser {
-    private message;
-    private position;
-    private locale?;
-    private ignoreTag;
-    private requiresOtherClause;
-    private shouldParseSkeletons?;
-    constructor(message: string, options?: ParserOptions);
-    parse(): Result<MessageFormatElement[], ParserError>;
-    private parseMessage;
-    /**
-     * A tag name must start with an ASCII lower/upper case letter. The grammar is based on the
-     * [custom element name][] except that a dash is NOT always mandatory and uppercase letters
-     * are accepted:
-     *
-     * ```
-     * tag ::= "<" tagName (whitespace)* "/>" | "<" tagName (whitespace)* ">" message "</" tagName (whitespace)* ">"
-     * tagName ::= [a-z] (PENChar)*
-     * PENChar ::=
-     *     "-" | "." | [0-9] | "_" | [a-z] | [A-Z] | #xB7 | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x37D] |
-     *     [#x37F-#x1FFF] | [#x200C-#x200D] | [#x203F-#x2040] | [#x2070-#x218F] | [#x2C00-#x2FEF] |
-     *     [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
-     * ```
-     *
-     * [custom element name]: https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
-     * NOTE: We're a bit more lax here since HTML technically does not allow uppercase HTML element but we do
-     * since other tag-based engines like React allow it
-     */
-    private parseTag;
-    /**
-     * This method assumes that the caller has peeked ahead for the first tag character.
-     */
-    private parseTagName;
-    private parseLiteral;
-    tryParseLeftAngleBracket(): string | null;
-    /**
-     * Starting with ICU 4.8, an ASCII apostrophe only starts quoted text if it immediately precedes
-     * a character that requires quoting (that is, "only where needed"), and works the same in
-     * nested messages as on the top level of the pattern. The new behavior is otherwise compatible.
-     */
-    private tryParseQuote;
-    private tryParseUnquoted;
-    private parseArgument;
-    /**
-     * Advance the parser until the end of the identifier, if it is currently on
-     * an identifier character. Return an empty string otherwise.
-     */
-    private parseIdentifierIfPossible;
-    private parseArgumentOptions;
-    private tryParseArgumentClose;
-    /**
-     * See: https://github.com/unicode-org/icu/blob/af7ed1f6d2298013dc303628438ec4abe1f16479/icu4c/source/common/messagepattern.cpp#L659
-     */
-    private parseSimpleArgStyleIfPossible;
-    private parseNumberSkeletonFromString;
-    /**
-     * @param nesting_level The current nesting level of messages.
-     *     This can be positive when parsing message fragment in select or plural argument options.
-     * @param parent_arg_type The parent argument's type.
-     * @param parsed_first_identifier If provided, this is the first identifier-like selector of
-     *     the argument. It is a by-product of a previous parsing attempt.
-     * @param expecting_close_tag If true, this message is directly or indirectly nested inside
-     *     between a pair of opening and closing tags. The nested message will not parse beyond
-     *     the closing tag boundary.
-     */
-    private tryParsePluralOrSelectOptions;
-    private tryParseDecimalInteger;
-    private offset;
-    private isEOF;
-    private clonePosition;
-    /**
-     * Return the code point at the current position of the parser.
-     * Throws if the index is out of bound.
-     */
-    private char;
-    private error;
-    /** Bump the parser to the next UTF-16 code unit. */
-    private bump;
-    /**
-     * If the substring starting at the current position of the parser has
-     * the given prefix, then bump the parser to the character immediately
-     * following the prefix and return true. Otherwise, don't bump the parser
-     * and return false.
-     */
-    private bumpIf;
-    /**
-     * Bump the parser until the pattern character is found and return `true`.
-     * Otherwise bump to the end of the file and return `false`.
-     */
-    private bumpUntil;
-    /**
-     * Bump the parser to the target offset.
-     * If target offset is beyond the end of the input, bump the parser to the end of the input.
-     */
-    private bumpTo;
-    /** advance the parser through all whitespace to the next non-whitespace code unit. */
-    private bumpSpace;
-    /**
-     * Peek at the *next* Unicode codepoint in the input without advancing the parser.
-     * If the input has been exhausted, then this returns null.
-     */
-    private peek;
-}