soml-lang 0.0.1 → 0.0.2

package/source/shared.js

@@ -1,166 +0,0 @@
-/*
-The deepest nesting either direction accepts. A recursive-descent parser would otherwise end in an engine stack overflow.
-*/
-export const MAX_DEPTH = 1000;
-
-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 = Temporal.Instant.from('0001-01-01T00:00:00Z').epochNanoseconds;
-export const MAX_INSTANT = Temporal.Instant.from('9999-12-31T23:59:59.999999999Z').epochNanoseconds;
-
-/*
-The duration units in their required order, with their length in nanoseconds.
-*/
-export const DURATION_UNITS = new Map([
-	['h', 3_600_000_000_000n],
-	['m', 60_000_000_000n],
-	['s', 1_000_000_000n],
-	['ms', 1_000_000n],
-	['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;
-	}
-
-	return new Temporal.Duration(0, 0, 0, 0, ...parts);
-}
-
-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.
-*/
-export const bareKeyCharacters = new Uint8Array(128);
-
-for (const character of 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-') {
-	bareKeyCharacters[character.codePointAt(0)] = 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++) {
-		const code = key.charCodeAt(index);
-
-		if (code >= 128 || bareKeyCharacters[code] !== 1) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-/**
-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)`.
-@param codePoint
-*/
-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/source/stringify.js

@@ -1,439 +0,0 @@
-import {
-	MAX_DEPTH,
-	INT64_MIN,
-	INT64_MAX,
-	MIN_INSTANT,
-	MAX_INSTANT,
-	DURATION_UNITS,
-	trimTrailingZeros,
-	validateIntegersOption,
-	isBareKey,
-	abbreviate,
-} from './shared.js';
-
-const instantNanoseconds = Object.getOwnPropertyDescriptor(Temporal.Instant.prototype, 'epochNanoseconds').get;
-const dateTime = Date.prototype.getTime;
-const durationField = name => Object.getOwnPropertyDescriptor(Temporal.Duration.prototype, name).get;
-const durationCalendarFields = ['years', 'months', 'weeks', 'days'].map(name => durationField(name));
-// In the order of `DURATION_UNITS`.
-const durationTimeFields = ['hours', 'minutes', 'seconds', 'milliseconds', 'microseconds', 'nanoseconds'].map(name => durationField(name));
-const durationSizes = DURATION_UNITS.values().toArray();
-const 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 a value to canonical form.
-
-@param {object} value
-@param {{integers?: 'bigint' | 'number'}} [options]
-*/
-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;
-	}
-
-	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('');
-	}
-
-	/*
-	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]') {
-			return formatInstant(readBranded(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) * 1_000_000n);
-		}
-
-		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);
-	}
-}
-
-/*
-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(); // eslint-disable-line unicorn/require-array-sort-compare -- 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 ? `an instance of ${name}` : 'an object');
-	}
-
-	if (value === undefined) {
-		return 'undefined';
-	}
-
-	return `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) {
-	if (isBareKey(key)) {
-		return key;
-	}
-
-	return 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 === Number.NEGATIVE_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) {
-	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 / 3_600_000_000_000n;
-	const minutes = (magnitude / 60_000_000_000n) % 60n;
-	const seconds = (magnitude / 1_000_000_000n) % 60n;
-	const fraction = magnitude % 1_000_000_000n;
-	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 Temporal.Instant(nanoseconds);
-
-	if (nanoseconds < MIN_INSTANT || nanoseconds > MAX_INSTANT) {
-		throw new RangeError(`Cannot serialize the instant ${instant}, because it is outside the years 0001 to 9999`);
-	}
-
-	return instant.toString();
-}