@clementine-solutions/jane-io 1.0.1 → 1.0.3

package/dist/core/normalizers/normalizer-register.js

@@ -0,0 +1,41 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Public | Normalizer Registry
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Exposes the full mapping of structural types to their
+ *                  associated normalization rules, defining Jane’s public
+ *                  normalization pipeline surface.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { collapseWhitespace, compactSparseArray, emptyToUndefined, flattenOneLevel, infinityToUndefined, invalidDateToUndefined, nanToUndefined, normalizeNegativeZero, removeEmptyArrayKeys, removeEmptyObjectKeys, removeEmptyStringItems, removeEmptyStringKeys, removeNullItems, removeNullKeys, removeUndefinedItems, removeUndefinedKeys, trim, } from '.';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Normalization Rule Registry                                               *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Maps each structural type to the normalization rules that apply to it,
+ * defining the full normalization pipeline Jane runs for incoming values.
+ */
+export const normalizationRuleRegistry = {
+    string: [trim, collapseWhitespace, emptyToUndefined],
+    number: [normalizeNegativeZero, nanToUndefined, infinityToUndefined],
+    boolean: [],
+    array: [
+        compactSparseArray,
+        flattenOneLevel,
+        removeEmptyStringItems,
+        removeNullItems,
+        removeUndefinedItems,
+    ],
+    object: [
+        removeUndefinedKeys,
+        removeNullKeys,
+        removeEmptyStringKeys,
+        removeEmptyArrayKeys,
+        removeEmptyObjectKeys,
+    ],
+    date: [invalidDateToUndefined],
+    unknown: [],
+    bigint: [],
+};

package/dist/core/normalizers/number/infinity-to-undefined.js

@@ -0,0 +1,35 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Infinity To Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts `Infinity` and `-Infinity` to `undefined`, removing
+ *                  non‑finite numeric values that cannot be represented or
+ *                  validated safely.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Converts `Infinity` and `-Infinity` to `undefined`, removing non‑finite
+ * numeric values that cannot be represented safely across serialization or
+ * downstream validation.
+ */
+export const infinityToUndefined = (value, _mode, path) => {
+    if (typeof value !== 'number')
+        return [];
+    if (value !== Infinity && value !== -Infinity)
+        return [];
+    const event = normalizationEvent('info', 'number.now.undefined', path, 'Converted Infinity or -Infinity to undefined.', 'Infinite values were removed.', { before: value, after: undefined });
+    return [
+        {
+            path,
+            nextValue: undefined,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/number/nan-to-undefined.js

@@ -0,0 +1,34 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | NaN to Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts `NaN` to `undefined`, eliminating invalid numeric
+ *                  states that cannot be compared, serialized, or reasoned
+ *                  about reliably.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Converts `NaN` to `undefined`, eliminating invalid numeric states that cannot
+ * be meaningfully compared, serialized, or validated.
+ */
+export const nanToUndefined = (value, _mode, path) => {
+    if (typeof value !== 'number')
+        return [];
+    if (!Number.isNaN(value))
+        return [];
+    const event = normalizationEvent('info', 'number.now.undefined', path, 'Converted NaN to undefined.', 'Invalid numeric values were removed.', { before: value, after: undefined });
+    return [
+        {
+            path,
+            nextValue: undefined,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/number/normalize-negative-zero.js

@@ -0,0 +1,33 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Normalize Negative Zero
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Normalizes `-0` to `0`, removing a JavaScript‑specific edge
+ *                  case while preserving the value’s intended semantics.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Normalizes `-0` to `0`, removing a JavaScript‑specific numeric edge case
+ * while preserving the value’s intended semantics.
+ */
+export const normalizeNegativeZero = (value, _mode, path) => {
+    if (typeof value !== 'number')
+        return [];
+    if (!Object.is(value, -0))
+        return [];
+    const event = normalizationEvent('info', 'number.now.positive-zero', path, 'Normalized -0 to 0.', 'Negative zero was corrected.', { before: value, after: 0 });
+    return [
+        {
+            path,
+            nextValue: 0,
+            lossy: 'lossless',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/object/remove-empty-array-keys.js

@@ -0,0 +1,38 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty Array Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are empty arrays, eliminating
+ *                  structurally empty list fields while preserving all
+ *                  non‑empty array data.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes keys whose values are empty arrays, eliminating structurally empty
+ * list fields while preserving all non‑empty array values.
+ */
+export const removeEmptyArrayKeys = (value, _mode, path) => {
+    if (value === null || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return [];
+    const entries = Object.entries(value).filter(([_, v]) => !Array.isArray(v) || v.length > 0);
+    if (entries.length === Object.keys(value).length)
+        return [];
+    const nextValue = Object.fromEntries(entries);
+    const event = normalizationEvent('info', 'object.without.empty-arrays', path, 'Removed keys whose values were empty arrays.', 'Empty lists were removed.', { before: value, after: nextValue });
+    return [
+        {
+            path,
+            nextValue,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/object/remove-empty-object-keys.js

@@ -0,0 +1,42 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty Object Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are empty plain objects, clearing
+ *                  fields that carry no structural or semantic content.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes keys whose values are empty plain objects, filtering out fields that
+ * carry no structural or semantic content.
+ */
+export const removeEmptyObjectKeys = (value, _mode, path) => {
+    if (value === null || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return [];
+    const entries = Object.entries(value).filter(([_, v]) => {
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            return Object.keys(v).length > 0;
+        }
+        return true;
+    });
+    if (entries.length === Object.keys(value).length)
+        return [];
+    const nextValue = Object.fromEntries(entries);
+    const event = normalizationEvent('info', 'object.without.empty-objects', path, 'Removed keys whose values were empty objects.', 'Empty objects were removed.', { before: value, after: nextValue });
+    return [
+        {
+            path,
+            nextValue,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/object/remove-empty-string-keys.js

@@ -0,0 +1,37 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty String Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are empty strings, eliminating
+ *                  placeholder or accidental text fields.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes keys whose values are empty strings, clearing out placeholder or
+ * accidental text fields while retaining all meaningful values.
+ */
+export const removeEmptyStringKeys = (value, _mode, path) => {
+    if (value === null || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return [];
+    const entries = Object.entries(value).filter(([_, v]) => v !== '');
+    if (entries.length === Object.keys(value).length)
+        return [];
+    const nextValue = Object.fromEntries(entries);
+    const event = normalizationEvent('info', 'object.without.empty-strings', path, 'Removed keys whose values were empty strings.', 'Empty text values were removed.', { before: value, after: nextValue });
+    return [
+        {
+            path,
+            nextValue,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/object/remove-null-keys.js

@@ -0,0 +1,37 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Null Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are null, stripping explicitly
+ *                  empty fields while preserving all defined data.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes keys whose values are null, eliminating explicitly empty fields while
+ * preserving all defined data.
+ */
+export const removeNullKeys = (value, _mode, path) => {
+    if (value === null || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return [];
+    const entries = Object.entries(value).filter(([_, v]) => v !== null);
+    if (entries.length === Object.keys(value).length)
+        return [];
+    const nextValue = Object.fromEntries(entries);
+    const event = normalizationEvent('info', 'object.without.null-keys', path, 'Removed keys whose values were null.', 'Null values were removed.', { before: value, after: nextValue });
+    return [
+        {
+            path,
+            nextValue,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/object/remove-undefined-keys.js

@@ -0,0 +1,37 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Undefined Keys
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes keys whose values are undefined, producing a cleaner
+ *                  and more predictable object shape.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Removes keys whose values are undefined, producing a cleaner and more
+ * predictable object shape by stripping absent fields.
+ */
+export const removeUndefinedKeys = (value, _mode, path) => {
+    if (value === null || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return [];
+    const entries = Object.entries(value).filter(([_, v]) => v !== undefined);
+    if (entries.length === Object.keys(value).length)
+        return [];
+    const nextValue = Object.fromEntries(entries);
+    const event = normalizationEvent('info', 'object.without.undefined-keys', path, 'Removed keys whose values were undefined.', 'Undefined values were removed.', { before: value, after: nextValue });
+    return [
+        {
+            path,
+            nextValue,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/string/collapse-whitespace.js

@@ -0,0 +1,35 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Collapse Whitespace
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Collapses repeated internal whitespace into a single space,
+ *                  producing cleaner, more consistent text without altering
+ *                  meaning.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Collapses repeated internal whitespace into a single space, producing a
+ * cleaner and more consistent text structure without altering meaning.
+ */
+export const collapseWhitespace = (value, _mode, path) => {
+    if (typeof value !== 'string')
+        return [];
+    const collapsed = value.replace(/\s+/g, ' ');
+    if (collapsed === value)
+        return [];
+    const event = normalizationEvent('info', 'string.now.collapsed', path, 'Collapsed repeated internal whitespace into a single space.', 'Extra spaces inside the text were cleaned up.', { before: value, after: collapsed });
+    return [
+        {
+            path,
+            nextValue: collapsed,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/string/empty-to-undefined.js

@@ -0,0 +1,33 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Empty To Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts empty strings to undefined, removing text fields
+ *                  that contain no meaningful content.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Converts empty strings to undefined, removing text fields that contain no
+ * meaningful content.
+ */
+export const emptyToUndefined = (value, _mode, path) => {
+    if (typeof value !== 'string')
+        return [];
+    if (value.length > 0)
+        return [];
+    const event = normalizationEvent('info', 'string.now.undefined', path, 'Converted empty string to undefined.', 'Empty text was removed.', { before: value, after: undefined });
+    return [
+        {
+            path,
+            nextValue: undefined,
+            lossy: 'lossy',
+            events: [event],
+        },
+    ];
+};

package/dist/core/normalizers/string/trim.js

@@ -0,0 +1,34 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Trim
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes leading and trailing whitespace, normalizing text
+ *                  edges while preserving internal content exactly as provided.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { normalizationEvent } from '../../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Trims leading and trailing whitespace, normalizing text edges while
+ * preserving the internal content exactly as provided.
+ */
+export const trim = (value, _mode, path) => {
+    if (typeof value !== 'string')
+        return [];
+    const trimmed = value.trim();
+    if (trimmed === value)
+        return [];
+    const event = normalizationEvent('info', 'string.now.trimmed', path, 'Removed leading and trailing whitespace.', 'Extra spaces at the beginning or end were removed.', { before: value, after: trimmed });
+    return [
+        {
+            path,
+            nextValue: trimmed,
+            lossy: 'lossless',
+            events: [event],
+        },
+    ];
+};

package/dist/core/parsers/index.js

@@ -0,0 +1,43 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Re‑exports all parser implementations, providing a unified
+ *                  entry point for Jane’s parsing subsystem.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Array Values                                                              *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseArrayString } from './parse-array-string';
+export { parseJsonString } from './parse-json-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Bigint Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseBigIntString } from './parse-bigint-string';
+export { parseBinaryString } from './parse-binary-string';
+export { parseHexString } from './parse-hex-string';
+export { parseOctalString } from './parse-octal-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Boolean Values                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseBooleanString } from './parse-boolean-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Date Values                                                               *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseIsoDateString } from './parse-date-string';
+export { parseDurationString } from './parse-duration-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Number Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseNumericString } from './parse-numeric-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Object Values                                                             *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseObjectString } from './parse-object-string';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* URL Values                                                                *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+export { parseUrlString } from './parse-url-string';

package/dist/core/parsers/parse-array-string.js

@@ -0,0 +1,36 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Array String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses JSON‑compatible array strings into actual arrays,
+ *                  rejecting ambiguous or non‑array input.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses JSON‑compatible array strings into actual arrays, rejecting anything
+ * that is not a syntactically valid array literal.
+ */
+export const parseArrayString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('[') || !trimmed.endsWith(']'))
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const event = parseEvent('info', 'string.now.array', 'Parsed string into a JSON array.', path, 'Converted text into a list.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-bigint-string.js

@@ -0,0 +1,33 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Bigint String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses canonical decimal bigint literals into `bigint`
+ *                  values, enforcing strict, non‑guessing numeric rules.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses canonical decimal bigint strings into `bigint` values, enforcing a
+ * strict digits‑only format with an optional leading minus.
+ */
+export const parseBigIntString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    if (!/^-?\d+$/.test(value))
+        return [];
+    let parsed;
+    try {
+        parsed = BigInt(value);
+    }
+    catch {
+        return [];
+    }
+    const event = parseEvent('info', 'string.now.bigint', `String parsed into bigint ${parsed}.`, path, 'Converted text into a large integer.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-binary-string.js

@@ -0,0 +1,33 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Binary String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses binary string literals (0b…) into `bigint` values,
+ *                  validating format and rejecting malformed input.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses binary string literals (`0b…`) into `bigint` values, validating format
+ * and rejecting malformed or non‑binary input.
+ */
+export const parseBinaryString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    if (!/^0b[01]+$/.test(value))
+        return [];
+    let parsed;
+    try {
+        parsed = BigInt(value);
+    }
+    catch {
+        return [];
+    }
+    const event = parseEvent('info', 'string.now.binary', `Binary string parsed into bigint ${parsed}.`, path, 'Converted binary text into a number.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};

package/dist/core/parsers/parse-boolean-string.js

@@ -0,0 +1,27 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Boolean String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict boolean strings (`"true"` / `"false"`) into
+ *                  boolean values without accepting loose or coercive forms.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { parseEvent } from '../pipeline';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Parses strict boolean strings (`"true"` or `"false"`) into boolean values,
+ * without accepting loose or coercive forms.
+ */
+export const parseBooleanString = (value, path) => {
+    if (typeof value !== 'string')
+        return [];
+    if (value !== 'true' && value !== 'false')
+        return [];
+    const parsed = value === 'true';
+    const event = parseEvent('info', 'string.now.boolean', `String parsed into boolean ${parsed}.`, path, 'Converted text into true or false.', { before: value, after: parsed });
+    return [{ path, nextValue: parsed, events: [event] }];
+};