@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/src/csvw/index.ts

@@ -0,0 +1,22 @@
+/**
+ * CSV on the Web (CSVW) for effect-rdf: metadata documents, the annotated
+ * tabular data model with validation, and the CSV2RDF and CSV2JSON
+ * conversions, over already-parsed tables.
+ *
+ * @since 0.1.0
+ */
+
+/** @since 0.1.0 */
+export * as Csv2Json from './Csv2Json.ts';
+/** @since 0.1.0 */
+export * as Csv2Rdf from './Csv2Rdf.ts';
+/** @since 0.1.0 */
+export * as Datatype from './Datatype.ts';
+/** @since 0.1.0 */
+export * as Metadata from './Metadata.ts';
+/** @since 0.1.0 */
+export * as Processor from './Processor.ts';
+/** @since 0.1.0 */
+export * as Report from './Report.ts';
+/** @since 0.1.0 */
+export * as Table from './Table.ts';

package/src/csvw/internal/dateFormat.ts

@@ -0,0 +1,202 @@
+/**
+ * Date and time formats (Tabular Data Model §Formats for dates and times):
+ * the UAX 35 date field symbols the specification requires (`yyyy`, `MM`,
+ * `M`, `dd`, `d`, `HH`, `mm`, `ss`, `S…`, `X…`, `x…`), compiled to a matcher
+ * that yields the XML Schema lexical form.
+ *
+ * @internal
+ */
+import * as Arr from 'effect/Array';
+import * as Option from 'effect/Option';
+import * as Record from 'effect/Record';
+import * as Result from 'effect/Result';
+
+type Field = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'fraction' | 'tz';
+
+interface Token {
+  readonly field: Option.Option<Field>;
+  readonly source: string;
+}
+
+/**
+ * A compiled date/time pattern.
+ *
+ * @internal
+ */
+export interface DatePattern {
+  readonly regex: RegExp;
+  readonly fields: ReadonlyArray<Field>;
+  readonly hasDate: boolean;
+  readonly hasTime: boolean;
+}
+
+/** Timezone offsets by marker length (`x`, `xx`, `xxx`); `X…` also allows `Z`. */
+const TZ_OFFSETS = ['[+-]\\d{2}(?:\\d{2})?', '[+-]\\d{4}', '[+-]\\d{2}:\\d{2}'];
+
+const field = (f: Field, source: string): Option.Option<Token> =>
+  Option.some({ field: Option.some(f), source: `(${source})` });
+
+const tzOffset = (n: number, allowZ: boolean): Option.Option<Token> =>
+  Option.flatMap(Arr.get(TZ_OFFSETS, n - 1), (offset) =>
+    field('tz', allowZ ? `Z|${offset}` : offset),
+  );
+
+const tokenize = (pattern: string): ReadonlyArray<string> => pattern.match(/(.)\1*/gu) ?? [];
+
+/** A field symbol of exactly `n` letters (`yyyy`, `HH`, …). */
+const exactly =
+  (n: number, f: Field, source: string) =>
+  (length: number): Option.Option<Token> =>
+    length === n ? field(f, source) : Option.none();
+
+/** A one- or two-letter numeric field (`M` / `MM`, `d` / `dd`). */
+const oneOrTwo =
+  (f: Field) =>
+  (length: number): Option.Option<Token> =>
+    length > 2 ? Option.none() : field(f, length === 2 ? '\\d{2}' : '\\d{1,2}');
+
+/** The field symbols this implementation recognises, by letter. */
+const symbols: Readonly<Record<string, (length: number) => Option.Option<Token>>> = {
+  y: exactly(4, 'year', '\\d{4}'),
+  M: oneOrTwo('month'),
+  d: oneOrTwo('day'),
+  H: exactly(2, 'hour', '\\d{2}'),
+  m: exactly(2, 'minute', '\\d{2}'),
+  s: exactly(2, 'second', '\\d{2}'),
+  S: (length) => field('fraction', `\\d{1,${length}}`),
+  X: (length) => tzOffset(length, true),
+  x: (length) => tzOffset(length, false),
+};
+
+const literal = (run: string): Option.Option<Token> =>
+  /^[-/.: T]+$/.test(run)
+    ? Option.some({ field: Option.none(), source: run.replace(/[.]/g, '\\.') })
+    : Option.none();
+
+const compileToken = (run: string): Option.Option<Token> =>
+  Option.match(Record.get(symbols, run.charAt(0)), {
+    onNone: () => literal(run),
+    onSome: (symbol) => symbol(run.length),
+  });
+
+/**
+ * Compiles a date/time pattern; `None` when it uses a symbol this
+ * implementation does not recognise.
+ *
+ * @internal
+ */
+export const compile = (pattern: string): Option.Option<DatePattern> => {
+  const tokens = Arr.map(tokenize(pattern), compileToken);
+  if (!Arr.every(tokens, Option.isSome) || !Arr.isReadonlyArrayNonEmpty(tokens))
+    return Option.none();
+  const compiled = Arr.getSomes(tokens);
+  const fields = Arr.getSomes(Arr.map(compiled, (t) => t.field));
+  const has = (f: Field) => Arr.contains(fields, f);
+  const hasDate = has('year') || has('month') || has('day');
+  const hasTime = has('hour') || has('minute') || has('second');
+  if (Arr.length(Arr.dedupe(fields)) !== Arr.length(fields)) return Option.none();
+  if (has('fraction') && !has('second')) return Option.none();
+  return Option.some({
+    regex: new RegExp(
+      `^${Arr.join(
+        Arr.map(compiled, (t) => t.source),
+        '',
+      )}$`,
+      'u',
+    ),
+    fields,
+    hasDate,
+    hasTime,
+  });
+};
+
+const pad = (s: string, n: number): string => s.padStart(n, '0');
+
+const timezone = (tz: string): string => {
+  if (tz === 'Z') return 'Z';
+  const sign = tz.charAt(0);
+  const digits = tz.slice(1).replace(':', '');
+  const hh = digits.slice(0, 2);
+  const mm = digits.length > 2 ? digits.slice(2, 4) : '00';
+  return `${sign}${hh}:${mm}`;
+};
+
+const daysInMonth = (year: number, month: number): number =>
+  month === 2
+    ? (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0
+      ? 29
+      : 28
+    : [4, 6, 9, 11].includes(month)
+      ? 30
+      : 31;
+
+interface Fields {
+  readonly date: string;
+  readonly time: string;
+  readonly tz: string;
+}
+
+const fieldsOf = (m: RegExpExecArray, pattern: DatePattern): Fields => {
+  const values = Arr.map(pattern.fields, (f, i) => [f, m[i + 1] ?? ''] as const);
+  const get = (f: Field, otherwise: string): string =>
+    Option.getOrElse(
+      Option.map(
+        Arr.findFirst(values, ([g]) => g === f),
+        ([, v]) => v,
+      ),
+      () => otherwise,
+    );
+  const fraction = get('fraction', '');
+  const tz = get('tz', '');
+  return {
+    date: `${get('year', '')}-${pad(get('month', ''), 2)}-${pad(get('day', ''), 2)}`,
+    time: `${get('hour', '00')}:${get('minute', '00')}:${get('second', '00')}${fraction === '' ? '' : `.${fraction}`}`,
+    tz: tz === '' ? '' : timezone(tz),
+  };
+};
+
+const validDate = (date: string): boolean => {
+  const [y = 0, mo = 0, d = 0] = Arr.map(date.split('-'), Number);
+  return mo >= 1 && mo <= 12 && d >= 1 && d <= daysInMonth(y, mo);
+};
+
+const validTime = (time: string): boolean => {
+  const [h = 0, mi = 0, s = 0] = Arr.map(time.split(':'), Number);
+  return h <= 23 && mi <= 59 && s < 60;
+};
+
+const lexicalFor = (
+  fields: Fields,
+  pattern: DatePattern,
+  base: string,
+): Result.Result<string, string> => {
+  if (base === 'date')
+    return pattern.hasDate ? Result.succeed(fields.date + fields.tz) : Result.fail('has no date');
+  if (base === 'time')
+    return pattern.hasTime ? Result.succeed(fields.time + fields.tz) : Result.fail('has no time');
+  if (!pattern.hasDate) return Result.fail('has no date');
+  if (base === 'dateTimeStamp' && fields.tz === '') return Result.fail('has no timezone');
+  return Result.succeed(`${fields.date}T${fields.time}${fields.tz}`);
+};
+
+/**
+ * Matches a cell string against a compiled pattern and returns the XML Schema
+ * lexical form for the base datatype (`date`, `time`, `dateTime` or
+ * `dateTimeStamp`).
+ *
+ * @internal
+ */
+export const parse = (
+  text: string,
+  pattern: DatePattern,
+  base: string,
+): Result.Result<string, string> =>
+  Option.match(Option.fromNullishOr(pattern.regex.exec(text)), {
+    onNone: () => Result.fail('does not match the format'),
+    onSome: (m) => {
+      const fields = fieldsOf(m, pattern);
+      if (pattern.hasDate && !validDate(fields.date)) return Result.fail('is not a valid date');
+      if (pattern.hasTime && !validTime(fields.time)) return Result.fail('is not a valid time');
+      return lexicalFor(fields, pattern, base);
+    },
+  });

package/src/csvw/internal/json.ts

@@ -0,0 +1,104 @@
+/**
+ * The one `JSON.parse` call of this package. It stays native because the
+ * engine's `SyntaxError` text is part of the metadata error messages, and
+ * `Schema.fromJsonString` replaces it with a generic issue.
+ *
+ * @internal
+ */
+import type * as Option from 'effect/Option';
+import * as Predicate from 'effect/Predicate';
+import * as Record from 'effect/Record';
+import * as Result from 'effect/Result';
+import type * as Schema from 'effect/Schema';
+
+/**
+ * Parses JSON text, failing with the engine's `SyntaxError` message.
+ *
+ * @internal
+ */
+export const parseJson = (text: string): Result.Result<Schema.Json, string> =>
+  Result.try({
+    try: (): Schema.Json => JSON.parse(text),
+    catch: (e) => (e instanceof SyntaxError ? e.message : String(e)),
+  });
+
+/**
+ * Whether a JSON value is an object (not an array, not `null`).
+ *
+ * @internal
+ */
+export const isObject = (value: Schema.Json): value is Schema.JsonObject =>
+  Predicate.isObject(value) && !Array.isArray(value);
+
+/**
+ * Whether a JSON value is an array.
+ *
+ * @internal
+ */
+export const isArray = (value: Schema.Json): value is Schema.JsonArray => Array.isArray(value);
+
+/**
+ * The entries of a JSON object, in insertion order.
+ *
+ * @internal
+ */
+export const entries = (obj: Schema.JsonObject): Array<[string, Schema.Json]> =>
+  Record.toEntries<string, Schema.Json>(obj);
+
+/**
+ * The keys of a JSON object, in insertion order.
+ *
+ * @internal
+ */
+export const keys = (obj: Schema.JsonObject): Array<string> =>
+  Record.keys<string, Schema.Json>(obj);
+
+/**
+ * Whether a JSON object has a key.
+ *
+ * @internal
+ */
+export const has = (obj: Schema.JsonObject, key: string): boolean => obj[key] !== undefined;
+
+/**
+ * The value of a key of a JSON object.
+ *
+ * @internal
+ */
+export const get = (obj: Schema.JsonObject, key: string): Option.Option<Schema.Json> =>
+  Record.get<string, Schema.Json>(obj, key);
+
+/**
+ * Maps the values of a JSON object.
+ *
+ * @internal
+ */
+export const mapValues = (
+  obj: Schema.JsonObject,
+  f: (value: Schema.Json, key: string) => Schema.Json,
+): Schema.JsonObject => Record.map<string, Schema.Json, Schema.Json>(obj, f);
+
+/**
+ * A JSON object with one key set.
+ *
+ * @internal
+ */
+export const set = (obj: Schema.JsonObject, key: string, value: Schema.Json): Schema.JsonObject =>
+  Record.set(
+    Record.map<string, Schema.Json, Schema.Json>(obj, (v) => v),
+    key,
+    value,
+  );
+
+/**
+ * A short description of a JSON value for messages: strings quoted, numbers
+ * and booleans as written, `null`, and the kind of anything else.
+ *
+ * @internal
+ */
+export const describe = (value: Schema.Json): string => {
+  if (Predicate.isString(value)) return `"${value}"`;
+  if (Predicate.isNumber(value) || Predicate.isBoolean(value)) return `${value}`;
+  if (Predicate.isNull(value)) return 'null';
+  return isArray(value) ? 'an array' : 'an object';
+};

package/src/csvw/internal/numberFormat.ts

@@ -0,0 +1,369 @@
+/**
+ * Numeric formats (Tabular Data Model §Formats for numeric types): the UAX 35
+ * number-pattern subset (`0`, `#`, the decimal and group characters, `E`,
+ * `+`, `-`, `%` and `‰`), the pattern-less grouped form, and the decimal
+ * arithmetic that applies percent and per-mille signs.
+ *
+ * @internal
+ */
+import * as Arr from 'effect/Array';
+import * as Option from 'effect/Option';
+import * as Result from 'effect/Result';
+
+/**
+ * A parsed number format pattern.
+ *
+ * @internal
+ */
+export interface Pattern {
+  readonly prefix: string;
+  readonly suffix: string;
+  /** Minimum integer digits (the `0`s of the integer part). */
+  readonly minInt: number;
+  /** Primary and secondary grouping sizes, if the integer part is grouped. */
+  readonly grouping: Option.Option<readonly [number, number]>;
+  readonly minFrac: number;
+  readonly maxFrac: number;
+  /** The fraction's grouping size, if it is grouped. */
+  readonly fracGrouping: Option.Option<number>;
+  readonly hasDecimal: boolean;
+  /** Minimum exponent digits, if the pattern has an exponent. */
+  readonly exponent: Option.Option<number>;
+}
+
+/**
+ * A numeric format: an optional pattern and the decimal and group characters.
+ *
+ * @internal
+ */
+export interface NumberFormat {
+  readonly pattern: Option.Option<Pattern>;
+  readonly decimalChar: string;
+  readonly groupChar: Option.Option<string>;
+}
+
+const escape = (s: string): string => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+const count = (s: string, c: string): number =>
+  Arr.length(Arr.filter(Array.from(s), (x) => x === c));
+
+/** Primary and secondary grouping sizes of a grouped integer pattern (`#,##,#00` → 3, 2). */
+const integerGrouping = (
+  segments: ReadonlyArray<string>,
+): Option.Option<Option.Option<readonly [number, number]>> =>
+  Arr.match(Arr.reverse(segments), {
+    onEmpty: () => Option.some(Option.none()),
+    onNonEmpty: ([primary, ...rest]) =>
+      Arr.match(rest, {
+        onEmpty: () => Option.some(Option.none()),
+        onNonEmpty: ([secondary, ...others]) => {
+          const size = Arr.isReadonlyArrayNonEmpty(others) ? secondary.length : primary.length;
+          return primary === '' || size === 0
+            ? Option.none()
+            : Option.some(Option.some([primary.length, size] as const));
+        },
+      }),
+  });
+
+/** The grouping size of a grouped fraction pattern (`0.0#,#` → 2). */
+const fractionGrouping = (segments: ReadonlyArray<string>): Option.Option<Option.Option<number>> =>
+  Arr.match(segments, {
+    onEmpty: () => Option.some(Option.none()),
+    onNonEmpty: ([first, ...rest]) =>
+      !Arr.isReadonlyArrayNonEmpty(rest)
+        ? Option.some(Option.none())
+        : first === ''
+          ? Option.none()
+          : Option.some(Option.some(first.length)),
+  });
+
+/** Whether `#`s precede the `0`s of the integer part and follow those of the fraction. */
+const wellOrdered = (int: string, frac: string): boolean =>
+  !/0[^0]*#/.test(int) && !/#[^#]*0/.test(frac);
+
+/**
+ * Parses a number format pattern; `None` when it uses anything this
+ * implementation does not recognise.
+ *
+ * @internal
+ */
+export const parsePattern = (
+  pattern: string,
+  decimalChar: string,
+  groupChar: string,
+): Option.Option<Pattern> => {
+  const g = escape(groupChar);
+  const re = new RegExp(
+    `^([+\\-%‰]*)([#0${g}]*[#0])(?:${escape(decimalChar)}([#0${g}]*))?(?:E(\\+?)([#0]+))?([%‰]*)$`,
+    'u',
+  );
+  return Option.flatMap(Option.fromNullishOr(re.exec(pattern)), (m) => {
+    const int = m[2] ?? '';
+    const frac = Option.fromNullishOr(m[3]);
+    const fracText = Option.getOrElse(frac, () => '');
+    const fracDigits = digitsOf(fracText, groupChar);
+    const affixes = (m[1] ?? '') + (m[6] ?? '');
+    if (!wellOrdered(digitsOf(int, groupChar), fracDigits)) return Option.none();
+    if (count(affixes, '%') + count(affixes, '‰') > 1) return Option.none();
+    return Option.map(
+      Option.all([
+        integerGrouping(int.split(groupChar)),
+        fractionGrouping(Option.isSome(frac) ? fracText.split(groupChar) : []),
+      ]),
+      ([grouping, fracGrouping]): Pattern => ({
+        prefix: m[1] ?? '',
+        suffix: m[6] ?? '',
+        minInt: count(int, '0'),
+        grouping,
+        minFrac: count(fracDigits, '0'),
+        maxFrac: fracDigits.length,
+        fracGrouping,
+        hasDecimal: Option.isSome(frac),
+        exponent: Option.map(Option.fromNullishOr(m[5]), (e) => count(e, '0')),
+      }),
+    );
+  });
+};
+
+/**
+ * The parts of a number read from a cell.
+ *
+ * @internal
+ */
+export interface Parsed {
+  /** The lexical form, with group characters removed and a `.` decimal point. */
+  readonly lexical: string;
+  readonly hasDecimal: boolean;
+  readonly hasExponent: boolean;
+  readonly special: boolean;
+}
+
+const checkIntegerGrouping = (
+  int: string,
+  groupChar: string,
+  grouping: Option.Option<readonly [number, number]>,
+): boolean => {
+  const groups = int.split(groupChar);
+  const ungrouped = !int.includes(groupChar);
+  return Option.match(grouping, {
+    onNone: () => ungrouped,
+    onSome: ([primary, secondary]) => {
+      if (ungrouped) return int.length <= primary;
+      const reversed = Arr.reverse(groups);
+      const last = Arr.length(reversed) - 1;
+      return Arr.every(reversed, (group, i) => {
+        const size = i === 0 ? primary : secondary;
+        return i === last ? group !== '' && group.length <= size : group.length === size;
+      });
+    },
+  });
+};
+
+const checkFractionGrouping = (
+  frac: string,
+  groupChar: string,
+  grouping: Option.Option<number>,
+): boolean => {
+  const groups = frac.split(groupChar);
+  return Option.match(grouping, {
+    onNone: () => !frac.includes(groupChar),
+    onSome: (size) =>
+      Arr.every(groups, (group, i) =>
+        i === Arr.length(groups) - 1 ? group !== '' && group.length <= size : group.length === size,
+      ),
+  });
+};
+
+const digitsOf = (s: string, groupChar: string): string => s.split(groupChar).join('');
+
+/**
+ * Shifts the decimal point of a decimal lexical form `places` to the left
+ * (dividing by 10^places), returning a canonical decimal.
+ *
+ * @internal
+ */
+export const shiftDecimal = (lexical: string, places: number): string => {
+  const negative = lexical.startsWith('-');
+  const unsigned = lexical.replace(/^[+-]/, '');
+  const [int = '', frac = ''] = unsigned.split('.');
+  const padded = int.padStart(places + 1, '0');
+  const newInt = padded.slice(0, padded.length - places).replace(/^0+(?=\d)/, '');
+  const newFrac = (padded.slice(padded.length - places) + frac).replace(/0+$/, '');
+  const body = newFrac === '' ? newInt : `${newInt}.${newFrac}`;
+  return negative && /[1-9]/.test(body) ? `-${body}` : body;
+};
+
+const SPECIAL = /^(?:NaN|INF|-INF)$/;
+
+interface Parts {
+  readonly sign: string;
+  readonly int: string;
+  readonly frac: Option.Option<string>;
+  readonly exp: Option.Option<string>;
+}
+
+/** The checks a number read with a pattern must pass, each failing with a reason. */
+const patternChecks: ReadonlyArray<
+  (parts: Parts, pattern: Pattern, g: string) => Option.Option<string>
+> = [
+  ({ int, frac }) =>
+    int === '' && Option.isNone(frac) ? Option.some('does not match the pattern') : Option.none(),
+  ({ int }, _, g) =>
+    int.endsWith(g) || int.includes(g + g)
+      ? Option.some('does not match the pattern')
+      : Option.none(),
+  ({ int }, pattern, g) =>
+    checkIntegerGrouping(int, g, pattern.grouping)
+      ? Option.none()
+      : Option.some('does not match the grouping of the pattern'),
+  ({ int }, pattern, g) =>
+    digitsOf(int, g).length < pattern.minInt
+      ? Option.some('has fewer integer digits than the pattern')
+      : Option.none(),
+  ({ frac }, pattern) =>
+    Option.isSome(frac) && !pattern.hasDecimal
+      ? Option.some('has a fraction the pattern does not allow')
+      : Option.none(),
+  ({ frac }, pattern, g) =>
+    Option.exists(
+      frac,
+      (f) =>
+        digitsOf(f, g).length > pattern.maxFrac ||
+        !checkFractionGrouping(f, g, pattern.fracGrouping),
+    )
+      ? Option.some('does not match the fraction of the pattern')
+      : Option.none(),
+  ({ frac }, pattern, g) =>
+    digitsOf(
+      Option.getOrElse(frac, () => ''),
+      g,
+    ).length < pattern.minFrac
+      ? Option.some('has fewer fraction digits than the pattern')
+      : Option.none(),
+  ({ exp }, pattern) =>
+    Option.match(pattern.exponent, {
+      onNone: () =>
+        Option.isSome(exp)
+          ? Option.some('has an exponent the pattern does not allow')
+          : Option.none(),
+      onSome: (min) =>
+        Option.exists(exp, (e) => e.replace(/^[+-]/, '').length >= min)
+          ? Option.none()
+          : Option.some('does not have the exponent digits of the pattern'),
+    }),
+];
+
+const partsOf = (body: string, format: NumberFormat, g: string): Option.Option<Parts> => {
+  const re = new RegExp(
+    `^([+-]?)(\\d[\\d${escape(g)}]*)?(?:${escape(format.decimalChar)}([\\d${escape(g)}]*))?(?:E([+-]?\\d+))?$`,
+    'u',
+  );
+  return Option.map(Option.fromNullishOr(re.exec(body)), (m) => ({
+    sign: m[1] ?? '',
+    int: m[2] ?? '',
+    frac: Option.fromNullishOr(m[3]),
+    exp: Option.fromNullishOr(m[4]),
+  }));
+};
+
+const parseWithPattern = (
+  text: string,
+  format: NumberFormat,
+  pattern: Pattern,
+): Result.Result<Parsed, string> => {
+  const g = Option.getOrElse(format.groupChar, () => ',');
+  const prefix = pattern.prefix.replace(/[+-]/g, '');
+  const suffix = pattern.suffix;
+  const parts =
+    text.startsWith(prefix) && text.endsWith(suffix)
+      ? partsOf(text.slice(prefix.length, text.length - suffix.length), format, g)
+      : Option.none();
+  return Option.match(parts, {
+    onNone: () => Result.fail('does not match the pattern'),
+    onSome: (p) =>
+      Option.match(
+        Arr.findFirst(patternChecks, (check) => Option.isSome(check(p, pattern, g))).pipe(
+          Option.flatMap((check) => check(p, pattern, g)),
+        ),
+        {
+          onSome: Result.fail,
+          onNone: () =>
+            Result.succeed(
+              finish(
+                p.sign,
+                digitsOf(p.int, g),
+                Option.map(p.frac, (f) => digitsOf(f, g)),
+                p.exp,
+                text,
+              ),
+            ),
+        },
+      ),
+  });
+};
+
+const finish = (
+  sign: string,
+  int: string,
+  frac: Option.Option<string>,
+  exp: Option.Option<string>,
+  text: string,
+): Parsed => {
+  const mantissa = `${sign}${int === '' ? '0' : int}${Option.match(frac, { onNone: () => '', onSome: (f) => `.${f}` })}`;
+  const plain = Option.match(exp, { onNone: () => mantissa, onSome: (e) => `${mantissa}e${e}` });
+  const percent = text.includes('%');
+  const permille = text.includes('‰');
+  const lexical =
+    percent || permille
+      ? Option.isNone(exp)
+        ? shiftDecimal(mantissa, percent ? 2 : 3)
+        : String(Number(plain) / (percent ? 100 : 1000))
+      : plain;
+  return {
+    lexical,
+    hasDecimal: Option.isSome(frac),
+    hasExponent: Option.isSome(exp),
+    special: false,
+  };
+};
+
+const parseWithoutPattern = (text: string, format: NumberFormat): Result.Result<Parsed, string> => {
+  if (SPECIAL.test(text))
+    return Result.succeed({ lexical: text, hasDecimal: false, hasExponent: false, special: true });
+  const g = Option.getOrUndefined(format.groupChar);
+  const d = format.decimalChar;
+  const groupClass = g === undefined ? '' : escape(g);
+  const re = new RegExp(
+    `^([+-]?)(\\d(?:\\d|${g === undefined ? '(?!)' : groupClass})*)?(?:${escape(d)}(\\d+))?(?:[Ee]([+-]?\\d+))?([%‰]?)$`,
+    'u',
+  );
+  const m = re.exec(text);
+  if (m === null || (m[2] === undefined && m[3] === undefined))
+    return Result.fail('is not a number');
+  const int = m[2] ?? '';
+  if (g !== undefined && (int.includes(g + g) || int.endsWith(g)))
+    return Result.fail('contains consecutive group characters');
+  return Result.succeed(
+    finish(
+      m[1] ?? '',
+      g === undefined ? int : digitsOf(int, g),
+      Option.fromNullishOr(m[3]),
+      Option.fromNullishOr(m[4]),
+      text,
+    ),
+  );
+};
+
+/**
+ * Parses a cell string with a numeric format.
+ *
+ * @internal
+ */
+export const parse = (text: string, format: NumberFormat): Result.Result<Parsed, string> =>
+  Option.match(format.pattern, {
+    onNone: () => parseWithoutPattern(text, format),
+    onSome: (pattern) =>
+      SPECIAL.test(text)
+        ? Result.succeed({ lexical: text, hasDecimal: false, hasExponent: false, special: true })
+        : parseWithPattern(text, format, pattern),
+  });