soml-lang 0.0.1 → 0.0.2

package/distribution/shared.d.ts

@@ -0,0 +1,48 @@
+export declare const MAX_DEPTH = 100;
+export declare const INT64_MIN: bigint;
+export declare const INT64_MAX: bigint;
+export declare const MIN_INSTANT = -62135596800000000000n;
+export declare const MAX_INSTANT = 253402300799999999999n;
+export declare function requireTemporal(): typeof globalThis.Temporal;
+export declare const DURATION_UNITS: Map<string, bigint>;
+/**
+Remove the trailing zeros of a run of digits. A loop rather than a regular expression, which would be quadratic on a long run of zeros followed by another digit.
+*/
+export declare function trimTrailingZeros(digits: string): string;
+/**
+A duration as a `Temporal.Duration` in hours and smaller units, which hold any int64 count of nanoseconds exactly.
+*/
+export declare function createDuration(nanoseconds: bigint): Temporal.Duration;
+export declare function validateIntegersOption(integers: unknown): asserts integers is 'bigint' | 'number';
+/**
+Whether a UTF-16 code unit can be part of a bare key. `NaN`, which `charCodeAt()` returns past the end of a string, cannot.
+*/
+export declare function isBareKeyCharacter(code: number): boolean;
+/**
+Whether a key can be written without quotes: one or more ASCII letters, digits, `_`, or `-`.
+*/
+export declare function isBareKey(key: string): boolean;
+/**
+The end of the number, instant, or duration token that starts at `start`, which is a digit or `-`.
+*/
+export declare function findNumberEnd(source: string, start: number): number;
+/**
+The offset of the line feed that ends the line containing `offset`, or the length of `source` on the last line.
+*/
+export declare function findLineEnd(source: string, offset: number): number;
+/**
+Find the closing delimiter of a block string: the first line from `offset` on that holds, after zero or more spaces and tabs, a run of exactly `length` of the `quote` character. A longer run is content. Returns where that line and its delimiter start, or `undefined` when no line closes the block.
+*/
+export declare function findBlockStringEnd(source: string, offset: number, quote: number, length: number): {
+    lineStart: number;
+    delimiterStart: number;
+} | undefined;
+/**
+Shorten text quoted in an error message, so a huge token does not make a huge message. The cut never splits a surrogate pair.
+*/
+export declare function abbreviate(text: string, maximumLength?: number): string;
+export declare function formatCodePoint(codePoint: number): string;
+/**
+Describe a character for an error message, such as `"$"` or `U+00A0 (NO-BREAK SPACE)`.
+*/
+export declare function describeCharacter(codePoint: number): string;

package/distribution/shared.js

@@ -0,0 +1,203 @@
+/*
+The deepest nesting either direction accepts. A recursive-descent parser would otherwise end in an engine stack overflow.
+*/
+export const MAX_DEPTH = 100;
+export const INT64_MIN = -(2n ** 63n);
+export const INT64_MAX = (2n ** 63n) - 1n;
+/*
+The instant range is checked in UTC, so that every instant has a canonical form that can be read back.
+*/
+export const MIN_INSTANT = -62135596800000000000n; // 0001-01-01T00:00:00Z
+export const MAX_INSTANT = 253402300799999999999n; // 9999-12-31T23:59:59.999999999Z
+/*
+`Temporal` is built into Node.js 26 and later. Before that, only instants and durations need it, so that everything else works without a polyfill. It is read at import, so a polyfill must be loaded before this package.
+*/
+const temporal = typeof Temporal === 'undefined' ? undefined : Temporal;
+export function requireTemporal() {
+    if (temporal === undefined) {
+        throw new Error('Instants and durations need `Temporal`. Use Node.js 26 or later, or load a polyfill such as `temporal-polyfill/global` before this package');
+    }
+    return temporal;
+}
+/*
+The duration units in their required order, with their length in nanoseconds.
+*/
+export const DURATION_UNITS = new Map([
+    ['h', 3600000000000n],
+    ['m', 60000000000n],
+    ['s', 1000000000n],
+    ['ms', 1000000n],
+    ['us', 1000n],
+    ['ns', 1n],
+]);
+/**
+Remove the trailing zeros of a run of digits. A loop rather than a regular expression, which would be quadratic on a long run of zeros followed by another digit.
+*/
+export function trimTrailingZeros(digits) {
+    let end = digits.length;
+    while (end > 0 && digits.charCodeAt(end - 1) === 0x30) {
+        end--;
+    }
+    return digits.slice(0, end);
+}
+/**
+A duration as a `Temporal.Duration` in hours and smaller units, which hold any int64 count of nanoseconds exactly.
+*/
+export function createDuration(nanoseconds) {
+    const sign = nanoseconds < 0n ? -1n : 1n;
+    let rest = nanoseconds * sign;
+    const parts = [];
+    for (const size of DURATION_UNITS.values()) {
+        parts.push(Number(sign * (rest / size)));
+        rest %= size;
+    }
+    const [hours, minutes, seconds, milliseconds, microseconds, nanosecondsPart] = parts;
+    return new (requireTemporal().Duration)(0, 0, 0, 0, hours, minutes, seconds, milliseconds, microseconds, nanosecondsPart);
+}
+export function validateIntegersOption(integers) {
+    if (integers !== 'bigint' && integers !== 'number') {
+        throw new TypeError(`The \`integers\` option must be 'bigint' or 'number', got ${typeof integers === 'string' ? `'${abbreviate(integers)}'` : typeof integers}`);
+    }
+}
+/*
+Names for the characters that are invisible or easy to mistake, so an error can say what it found.
+*/
+const CHARACTER_NAMES = new Map([
+    [0x06_1C, 'ARABIC LETTER MARK'],
+    [0x85, 'NEXT LINE'],
+    [0xA0, 'NO-BREAK SPACE'],
+    [0xAD, 'SOFT HYPHEN'],
+    [0x16_80, 'OGHAM SPACE MARK'],
+    [0x20_00, 'EN QUAD'],
+    [0x20_01, 'EM QUAD'],
+    [0x20_02, 'EN SPACE'],
+    [0x20_03, 'EM SPACE'],
+    [0x20_04, 'THREE-PER-EM SPACE'],
+    [0x20_05, 'FOUR-PER-EM SPACE'],
+    [0x20_06, 'SIX-PER-EM SPACE'],
+    [0x20_07, 'FIGURE SPACE'],
+    [0x20_08, 'PUNCTUATION SPACE'],
+    [0x20_09, 'THIN SPACE'],
+    [0x20_0A, 'HAIR SPACE'],
+    [0x20_0B, 'ZERO WIDTH SPACE'],
+    [0x20_0C, 'ZERO WIDTH NON-JOINER'],
+    [0x20_0D, 'ZERO WIDTH JOINER'],
+    [0x20_0E, 'LEFT-TO-RIGHT MARK'],
+    [0x20_0F, 'RIGHT-TO-LEFT MARK'],
+    [0x20_28, 'LINE SEPARATOR'],
+    [0x20_29, 'PARAGRAPH SEPARATOR'],
+    [0x20_2A, 'LEFT-TO-RIGHT EMBEDDING'],
+    [0x20_2B, 'RIGHT-TO-LEFT EMBEDDING'],
+    [0x20_2C, 'POP DIRECTIONAL FORMATTING'],
+    [0x20_2D, 'LEFT-TO-RIGHT OVERRIDE'],
+    [0x20_2E, 'RIGHT-TO-LEFT OVERRIDE'],
+    [0x20_2F, 'NARROW NO-BREAK SPACE'],
+    [0x20_5F, 'MEDIUM MATHEMATICAL SPACE'],
+    [0x20_60, 'WORD JOINER'],
+    [0x20_66, 'LEFT-TO-RIGHT ISOLATE'],
+    [0x20_67, 'RIGHT-TO-LEFT ISOLATE'],
+    [0x20_68, 'FIRST STRONG ISOLATE'],
+    [0x20_69, 'POP DIRECTIONAL ISOLATE'],
+    [0x30_00, 'IDEOGRAPHIC SPACE'],
+    [0xFE_FF, 'ZERO WIDTH NO-BREAK SPACE'],
+]);
+/*
+Letters, digits, `_`, and `-`, the characters of a bare key, as a lookup table by code unit.
+*/
+const bareKeyCharacters = new Uint8Array(128);
+for (const character of 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-') {
+    bareKeyCharacters[character.charCodeAt(0)] = 1;
+}
+/*
+A number, an instant, or a duration is lexed as one maximal run of these characters, and then validated as a whole. The validation is a hand-written scan rather than a regular expression, because a regular expression with a repeated group runs out of stack on a token of a few million characters.
+*/
+const numberCharacters = new Uint8Array(128);
+for (const character of 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.:+-') {
+    numberCharacters[character.charCodeAt(0)] = 1;
+}
+/**
+Whether a UTF-16 code unit can be part of a bare key. `NaN`, which `charCodeAt()` returns past the end of a string, cannot.
+*/
+export function isBareKeyCharacter(code) {
+    return code < 128 && bareKeyCharacters[code] === 1;
+}
+/**
+Whether a key can be written without quotes: one or more ASCII letters, digits, `_`, or `-`.
+*/
+export function isBareKey(key) {
+    if (key === '') {
+        return false;
+    }
+    for (let index = 0; index < key.length; index++) {
+        if (!isBareKeyCharacter(key.charCodeAt(index))) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+The end of the number, instant, or duration token that starts at `start`, which is a digit or `-`.
+*/
+export function findNumberEnd(source, start) {
+    let end = start + 1;
+    while (isNumberCharacter(source.charCodeAt(end))) {
+        end++;
+    }
+    return end;
+}
+function isNumberCharacter(code) {
+    return code < 128 && numberCharacters[code] === 1;
+}
+/**
+The offset of the line feed that ends the line containing `offset`, or the length of `source` on the last line.
+*/
+export function findLineEnd(source, offset) {
+    const end = source.indexOf('\n', offset);
+    return end === -1 ? source.length : end;
+}
+/**
+Find the closing delimiter of a block string: the first line from `offset` on that holds, after zero or more spaces and tabs, a run of exactly `length` of the `quote` character. A longer run is content. Returns where that line and its delimiter start, or `undefined` when no line closes the block.
+*/
+export function findBlockStringEnd(source, offset, quote, length) {
+    for (let lineStart = offset; lineStart < source.length; lineStart = findLineEnd(source, lineStart) + 1) {
+        let delimiterStart = lineStart;
+        while (source.charCodeAt(delimiterStart) === 0x20 || source.charCodeAt(delimiterStart) === 0x09) {
+            delimiterStart++;
+        }
+        let runLength = 0;
+        while (source.charCodeAt(delimiterStart + runLength) === quote) {
+            runLength++;
+        }
+        if (runLength === length) {
+            return { lineStart, delimiterStart };
+        }
+    }
+    return undefined;
+}
+/**
+Shorten text quoted in an error message, so a huge token does not make a huge message. The cut never splits a surrogate pair.
+*/
+export function abbreviate(text, maximumLength = 40) {
+    if (text.length <= maximumLength) {
+        return text;
+    }
+    const lastCode = text.charCodeAt(maximumLength - 1);
+    const end = lastCode >= 0xD8_00 && lastCode <= 0xDB_FF ? maximumLength - 1 : maximumLength;
+    return `${text.slice(0, end)}…`;
+}
+export function formatCodePoint(codePoint) {
+    return `U+${codePoint.toString(16).toUpperCase().padStart(4, '0')}`;
+}
+/**
+Describe a character for an error message, such as `"$"` or `U+00A0 (NO-BREAK SPACE)`.
+*/
+export function describeCharacter(codePoint) {
+    const name = CHARACTER_NAMES.get(codePoint);
+    if (name !== undefined) {
+        const isWhitespace = /^[\p{White_Space}\u{200B}\u{FEFF}]$/v.test(String.fromCodePoint(codePoint));
+        return `${formatCodePoint(codePoint)} (${name}${isWhitespace ? '; only space, tab, and line feed are whitespace' : ''})`;
+    }
+    const character = String.fromCodePoint(codePoint);
+    // Control, format, private-use, unassigned, surrogate, and separator characters are invisible or ambiguous, so they are shown by code point.
+    return codePoint !== 0x20 && /^[\p{Other}\p{Separator}]$/v.test(character) ? formatCodePoint(codePoint) : `"${character}"`;
+}

package/distribution/stringify.d.ts

@@ -0,0 +1,35 @@
+export type StringifyOptions = {
+    /**
+    How an int is represented in the value.
+
+    - `'bigint'`: A `bigint` is written as an int, and a `number` is always written as a float, so `8080` becomes `8080.0`.
+    - `'number'`: A `number` that is a safe integer is written as an int, and any other `number` as a float. A `bigint` is still written as an int.
+
+    @default 'bigint'
+    */
+    readonly integers?: 'bigint' | 'number';
+};
+/**
+Serialize an object or an array to canonical form.
+
+Canonical form is unique for a value: two equal values produce the same bytes, so the output can be hashed, signed, or compared. Members are sorted by key, and comments, dotted keys, and block strings are never written.
+
+A `bigint` is written as an int and a `number` as a float, so `{port: 8080}` becomes `port: 8080.0`. Use `8080n`, or the `integers: 'number'` option.
+
+A `Date` is accepted and written as an instant. A member whose value is `undefined` is left out.
+
+@param value - A plain object or an array.
+@param options - How to write ints.
+@returns The canonical form, ending with one line feed.
+@throws {TypeError} When the value contains something that cannot be represented, such as `NaN`, a function, a class instance, an invalid `Date`, a `Temporal.Duration` with years, months, weeks, or days, a circular reference, or a string or key with a lone surrogate or a carriage return. Also when `options.integers` is not `'bigint'` or `'number'`.
+@throws {RangeError} When an int is outside the 64-bit range, an instant is outside the years 0001 to 9999, a duration is outside the 64-bit range of nanoseconds, or the value is nested more than 100 levels deep.
+
+@example
+```
+import {stringify} from 'soml-lang';
+
+stringify({name: 'api-gateway', replicas: 3n, timeout: 30});
+//=> "name: 'api-gateway'\nreplicas: 3\ntimeout: 30.0\n"
+```
+*/
+export declare function stringify(value: object, options?: StringifyOptions): string;

package/distribution/stringify.js

@@ -0,0 +1,359 @@
+import { MAX_DEPTH, INT64_MIN, INT64_MAX, MIN_INSTANT, MAX_INSTANT, DURATION_UNITS, trimTrailingZeros, validateIntegersOption, requireTemporal, isBareKey, abbreviate, } from "./shared.js";
+const dateTime = Date.prototype.getTime;
+const durationField = (name) => Object.getOwnPropertyDescriptor(Temporal.Duration.prototype, name).get;
+const durationSizes = DURATION_UNITS.values().toArray();
+// Undefined without `Temporal`, and then `requireTemporal()` throws before it is used.
+const temporal = typeof Temporal === 'undefined'
+    ? undefined
+    : {
+        instantNanoseconds: Object.getOwnPropertyDescriptor(Temporal.Instant.prototype, 'epochNanoseconds').get,
+        durationCalendarFields: ['years', 'months', 'weeks', 'days'].map(name => durationField(name)),
+        // In the order of `DURATION_UNITS`.
+        durationTimeFields: ['hours', 'minutes', 'seconds', 'milliseconds', 'microseconds', 'nanoseconds'].map(name => durationField(name)),
+        durationToString: Temporal.Duration.prototype.toString,
+    };
+const HIGH_CODE_UNIT = /[\u{D800}-\u{10FFFF}]/v;
+// eslint-disable-next-line no-control-regex, regexp/no-control-character -- Control characters are exactly what must be found.
+const NEEDS_ESCAPED_STRING = /[\u{0}-\u{1F}'\u{7F}]/v;
+// eslint-disable-next-line no-control-regex, regexp/no-control-character -- As above, plus a lone surrogate, which the `v` flag matches only when it is unpaired.
+const NEEDS_ATTENTION = /[\u{0}-\u{1F}'\u{7F}\u{D800}-\u{DFFF}]/v;
+// eslint-disable-next-line no-control-regex, regexp/no-control-character -- Control characters are exactly what must be escaped.
+const ESCAPED_CHARACTER = /[\u{0}-\u{1F}"\\\u{7F}]/gv;
+const ESCAPES = {
+    '\\': '\\\\',
+    '"': String.raw `\"`,
+    '\n': String.raw `\n`,
+    '\t': String.raw `\t`,
+};
+/**
+Serialize an object or an array to canonical form.
+
+Canonical form is unique for a value: two equal values produce the same bytes, so the output can be hashed, signed, or compared. Members are sorted by key, and comments, dotted keys, and block strings are never written.
+
+A `bigint` is written as an int and a `number` as a float, so `{port: 8080}` becomes `port: 8080.0`. Use `8080n`, or the `integers: 'number'` option.
+
+A `Date` is accepted and written as an instant. A member whose value is `undefined` is left out.
+
+@param value - A plain object or an array.
+@param options - How to write ints.
+@returns The canonical form, ending with one line feed.
+@throws {TypeError} When the value contains something that cannot be represented, such as `NaN`, a function, a class instance, an invalid `Date`, a `Temporal.Duration` with years, months, weeks, or days, a circular reference, or a string or key with a lone surrogate or a carriage return. Also when `options.integers` is not `'bigint'` or `'number'`.
+@throws {RangeError} When an int is outside the 64-bit range, an instant is outside the years 0001 to 9999, a duration is outside the 64-bit range of nanoseconds, or the value is nested more than 100 levels deep.
+
+@example
+```
+import {stringify} from 'soml-lang';
+
+stringify({name: 'api-gateway', replicas: 3n, timeout: 30});
+//=> "name: 'api-gateway'\nreplicas: 3\ntimeout: 30.0\n"
+```
+*/
+// `object` rather than `Record<string, unknown>`, so that a value typed with an interface is accepted too. The value is checked at runtime.
+export function stringify(value, options = {}) {
+    const { integers = 'bigint' } = options;
+    validateIntegersOption(integers);
+    if (!Array.isArray(value) && !isPlainObject(value)) {
+        throw new TypeError(`The top-level value must be an object or an array, because a document is a collection. Got ${describeType(value)}`);
+    }
+    return new Writer(integers).writeDocument(value);
+}
+/*
+Appends to one array of parts that is joined once at the end, so the time is linear in the output whatever the nesting. A scalar and its line are one part.
+*/
+class Writer {
+    #integers;
+    #ancestors = new Set();
+    #parts = [];
+    constructor(integers) {
+        this.#integers = integers;
+    }
+    /*
+    Writes `prefix`, the value, and `suffix`. A container's own depth is `depth`, and its lines are indented by `indent`.
+    */
+    #writeItem(prefix, value, depth, indent, suffix, key) {
+        const scalar = this.#formatScalar(value, key);
+        if (scalar === undefined) {
+            this.#parts.push(prefix);
+            this.#writeContainer(value, depth, indent);
+            this.#parts.push(suffix);
+        }
+        else {
+            this.#parts.push(`${prefix}${scalar}${suffix}`);
+        }
+    }
+    /*
+    Formats a scalar, or returns `undefined` for an array or a plain object.
+    */
+    #formatScalar(value, key) {
+        switch (typeof value) {
+            case 'string': {
+                return formatString(value, 'string');
+            }
+            case 'bigint': {
+                return formatInteger(value);
+            }
+            case 'number': {
+                return this.#integers === 'number' && Number.isSafeInteger(value) ? formatInteger(BigInt(value)) : formatFloat(value);
+            }
+            case 'boolean': {
+                return value ? 'true' : 'false';
+            }
+            case 'object': {
+                break;
+            }
+            default: {
+                throw new TypeError(`Cannot serialize ${describeType(value)}${key === undefined ? '' : ` at key "${abbreviate(key)}"`}`);
+            }
+        }
+        if (value === null) {
+            return 'null';
+        }
+        if (Array.isArray(value) || isPlainObject(value)) {
+            return undefined;
+        }
+        // A brand check rather than `instanceof`, so that an instant or a date from another realm, such as a `vm` context, is accepted too. The tag is only a cheap filter, since `Symbol.toStringTag` can fake it. The getters read internal slots, so they throw for anything else.
+        const brand = Object.prototype.toString.call(value);
+        if (brand === '[object Temporal.Instant]') {
+            requireTemporal();
+            return formatInstant(readBranded(temporal.instantNanoseconds, value, 'Temporal.Instant'));
+        }
+        if (brand === '[object Temporal.Duration]') {
+            return formatDuration(value);
+        }
+        if (brand === '[object Date]') {
+            const milliseconds = readBranded(dateTime, value, 'Date');
+            if (Number.isNaN(milliseconds)) {
+                throw new TypeError('Cannot serialize an invalid Date');
+            }
+            return formatInstant(BigInt(milliseconds) * 1000000n);
+        }
+        throw new TypeError(`Cannot serialize ${describeType(value)}. Only plain objects, arrays, and the scalar types can be serialized`);
+    }
+    #enter(value, depth) {
+        if (depth > MAX_DEPTH) {
+            throw new RangeError(`Cannot serialize a value nested more than ${MAX_DEPTH} levels deep`);
+        }
+        if (this.#ancestors.has(value)) {
+            throw new TypeError('Cannot serialize a circular structure');
+        }
+        this.#ancestors.add(value);
+    }
+    #writeContainer(value, depth, indent) {
+        this.#enter(value, depth);
+        const parts = this.#parts;
+        const innerIndent = `${indent}\t`;
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                parts.push('[]');
+            }
+            else {
+                parts.push('[\n');
+                for (const [index, item] of value.entries()) {
+                    // A hole reads as `undefined`, and both would otherwise have to be guessed into something.
+                    if (item === undefined) {
+                        throw new TypeError(`Cannot serialize undefined in an array, at index ${index}`);
+                    }
+                    this.#writeItem(innerIndent, item, depth + 1, innerIndent, ',\n');
+                }
+                parts.push(`${indent}]`);
+            }
+        }
+        else {
+            const members = sortedMembers(value);
+            if (members.length === 0) {
+                parts.push('{}');
+            }
+            else {
+                parts.push('{\n');
+                for (const [key, member] of members) {
+                    this.#writeItem(`${innerIndent}${formatKey(key)}: `, member, depth + 1, innerIndent, ',\n', key);
+                }
+                parts.push(`${indent}}`);
+            }
+        }
+        this.#ancestors.delete(value);
+    }
+    writeDocument(value) {
+        if (Array.isArray(value)) {
+            this.#writeContainer(value, 1, '');
+            this.#parts.push('\n');
+            return this.#parts.join('');
+        }
+        this.#enter(value, 1);
+        const members = sortedMembers(value);
+        for (const [key, member] of members) {
+            this.#writeItem(`${formatKey(key)}: `, member, 2, '', '\n', key);
+        }
+        this.#ancestors.delete(value);
+        // A brace-less object needs at least one entry, so the empty object keeps its braces.
+        return members.length === 0 ? '{}\n' : this.#parts.join('');
+    }
+}
+/*
+The members to write, sorted by key, with each value read once. A member whose value is `undefined` is left out, as `JSON.stringify` does.
+*/
+function sortedMembers(object) {
+    const keys = Object.keys(object);
+    // The default sort compares UTF-16 code units, which matches code point order unless a key has a code unit from U+D800 up.
+    if (keys.some(key => HIGH_CODE_UNIT.test(key))) {
+        keys.sort(compareCodePoints);
+    }
+    else {
+        keys.sort(); // The native string order is the point, and it is much faster than a comparator.
+    }
+    const members = [];
+    for (const key of keys) {
+        const value = object[key];
+        if (value !== undefined) {
+            members.push([key, value]);
+        }
+    }
+    return members;
+}
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+function describeType(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (typeof value === 'number' && Number.isNaN(value)) {
+        return 'NaN, which is not representable';
+    }
+    if (typeof value === 'function') {
+        return 'a function';
+    }
+    if (typeof value === 'object') {
+        const name = value.constructor?.name;
+        return Array.isArray(value) ? 'an array' : (name === undefined || name === '' ? 'an object' : `an instance of ${name}`);
+    }
+    return value === undefined ? 'undefined' : `a ${typeof value}`;
+}
+/*
+Members are sorted by the Unicode scalar values of their keys. `Array#sort` compares UTF-16 code units, which orders U+E000 to U+FFFF after every astral character, so the code units are compared with surrogates moved above that range.
+*/
+function compareCodePoints(left, right) {
+    const length = Math.min(left.length, right.length);
+    for (let index = 0; index < length; index++) {
+        let leftCode = left.charCodeAt(index);
+        let rightCode = right.charCodeAt(index);
+        if (leftCode !== rightCode) {
+            if (leftCode >= 0xD8_00 && rightCode >= 0xD8_00) {
+                leftCode = toCodePointOrder(leftCode);
+                rightCode = toCodePointOrder(rightCode);
+            }
+            return leftCode - rightCode;
+        }
+    }
+    return left.length - right.length;
+}
+/*
+Moves U+E000 to U+FFFF down by 0x800 and the surrogates up by 0x2000, so the surrogates sort last.
+*/
+function toCodePointOrder(code) {
+    if (code >= 0xE0_00) {
+        return code - 0x8_00;
+    }
+    return code >= 0xD8_00 ? code + 0x20_00 : code;
+}
+function formatKey(key) {
+    return isBareKey(key) ? key : formatString(key, 'key');
+}
+function formatString(string, kind) {
+    // One scan settles the common case: no quote, no control character, and no lone surrogate.
+    if (!NEEDS_ATTENTION.test(string)) {
+        return `'${string}'`;
+    }
+    if (!string.isWellFormed()) {
+        throw new TypeError(`Cannot serialize a ${kind} containing a lone surrogate, which is not a Unicode scalar value`);
+    }
+    if (string.includes('\r')) {
+        throw new TypeError(`Cannot serialize a ${kind} containing a carriage return (U+000D), which is not representable`);
+    }
+    return NEEDS_ESCAPED_STRING.test(string) ? `"${string.replaceAll(ESCAPED_CHARACTER, character => ESCAPES[character] ?? String.raw `\u{${character.codePointAt(0).toString(16)}}`)}"` : `'${string}'`;
+}
+function formatInteger(value) {
+    if (value < INT64_MIN || value > INT64_MAX) {
+        throw new RangeError(`Cannot serialize the integer ${value}, because it is outside the 64-bit range`);
+    }
+    return String(value);
+}
+/*
+The shortest decimal that reads back as the same binary64 value, laid out as ECMAScript `Number::toString` does, which is also RFC 8785's choice. A fractional part is added when there is neither one nor an exponent, so that a float never reads back as an int.
+*/
+function formatFloat(value) {
+    if (Number.isNaN(value)) {
+        throw new TypeError('Cannot serialize NaN, which is not representable. Use null for a missing value');
+    }
+    if (value === Infinity) {
+        return 'infinity';
+    }
+    if (value === -Infinity) {
+        return '-infinity';
+    }
+    // Covers -0 too, since zero has one value whatever its sign.
+    if (value === 0) {
+        return '0.0';
+    }
+    const text = String(value);
+    if (text.includes('e')) {
+        return text.replace('e+', 'e');
+    }
+    return text.includes('.') ? text : `${text}.0`;
+}
+function readBranded(getter, value, name) {
+    try {
+        return getter.call(value);
+    }
+    catch {
+        throw new TypeError(`Cannot serialize an object that claims to be a ${name} but is not one`);
+    }
+}
+/*
+The total is computed from the fields as BigInts, because `Temporal.Duration#total()` returns a float, which cannot hold every int64 count of nanoseconds.
+*/
+function formatDuration(duration) {
+    requireTemporal();
+    const { durationCalendarFields, durationTimeFields, durationToString } = temporal;
+    if (durationCalendarFields.some(getter => readBranded(getter, duration, 'Temporal.Duration') !== 0)) {
+        throw new TypeError(`Cannot serialize the duration ${durationToString.call(duration)}, because years, months, weeks, and days are not a fixed length. Use hours or smaller units`);
+    }
+    let nanoseconds = 0n;
+    for (const [index, getter] of durationTimeFields.entries()) {
+        nanoseconds += BigInt(getter.call(duration)) * durationSizes[index];
+    }
+    if (nanoseconds < INT64_MIN || nanoseconds > INT64_MAX) {
+        throw new RangeError(`Cannot serialize the duration ${durationToString.call(duration)}, because it is outside the 64-bit range of nanoseconds`);
+    }
+    if (nanoseconds === 0n) {
+        return '0s';
+    }
+    const magnitude = nanoseconds < 0n ? -nanoseconds : nanoseconds;
+    const hours = magnitude / 3600000000000n;
+    const minutes = (magnitude / 60000000000n) % 60n;
+    const seconds = (magnitude / 1000000000n) % 60n;
+    const fraction = magnitude % 1000000000n;
+    let text = nanoseconds < 0n ? '-' : '';
+    if (hours > 0n) {
+        text += `${hours}h`;
+    }
+    if (minutes > 0n) {
+        text += `${minutes}m`;
+    }
+    if (seconds > 0n || fraction > 0n) {
+        // The fraction is written like an instant's: nine digits with the trailing zeros removed.
+        text += fraction === 0n ? `${seconds}s` : `${seconds}.${trimTrailingZeros(String(fraction).padStart(9, '0'))}s`;
+    }
+    return text;
+}
+function formatInstant(nanoseconds) {
+    const instant = new (requireTemporal().Instant)(nanoseconds);
+    if (nanoseconds < MIN_INSTANT || nanoseconds > MAX_INSTANT) {
+        throw new RangeError(`Cannot serialize the instant ${instant.toString()}, because it is outside the years 0001 to 9999`);
+    }
+    return instant.toString();
+}