@clementine-solutions/jane-io 1.0.0 → 1.0.1

package/dist/core/normalizers/array/compact-sparse-array.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Compact Sparse Array
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes sparse array holes while preserving all defined
+ *                  elements, producing a dense structure without altering the
+ *                  array’s semantic content.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Compacts sparse arrays by removing empty slots while preserving all defined
+ * elements. This targets only structural holes—never values—ensuring arrays
+ * become dense without altering their semantic content.
+ *
+ * Useful for normalizing inputs that originate from user interfaces, spread
+ * operations, or partial constructions where sparse positions may appear
+ * unintentionally.
+ */
+export declare const compactSparseArray: NormalizationRule<unknown>;

package/dist/core/normalizers/array/flatten-one-level.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Empty String Items
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes empty string entries from arrays, eliminating
+ *                  placeholder or accidental text values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Flattens nested arrays by a single level, simplifying structure while
+ * preserving item order. Useful for normalizing inputs where shallow nesting
+ * appears unintentionally.
+ */
+export declare const flattenOneLevel: NormalizationRule<unknown>;

package/dist/core/normalizers/array/remove-empty-string-items.d.ts

@@ -0,0 +1,6 @@
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Removes empty string entries from arrays, eliminating placeholder or
+ * accidental text values while preserving all meaningful items.
+ */
+export declare const removeEmptyStringItems: NormalizationRule<unknown>;

package/dist/core/normalizers/array/remove-null-items.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Null Items
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Filters out null entries from arrays, removing structurally
+ *                  empty items while preserving all defined values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Filters out null entries from arrays, removing structurally empty items
+ * without altering the order or meaning of defined values.
+ */
+export declare const removeNullItems: NormalizationRule<unknown>;

package/dist/core/normalizers/array/remove-undefined-items.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Remove Undefined Items
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Removes undefined entries from arrays, producing a cleaner
+ *                  and more predictable sequence of defined values.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Removes undefined entries from arrays, producing a cleaner and more
+ * predictable sequence of defined values.
+ */
+export declare const removeUndefinedItems: NormalizationRule<unknown>;

package/dist/core/normalizers/date/invalid-date-to-undefined.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Normalizers | Invalid Date To Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Converts invalid Date instances (timestamp NaN) to undefined,
+ *                  preventing malformed or unparsable date values from
+ *                  propagating through normalization.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { NormalizationRule } from '../../shapes';
+/**
+ * Converts invalid Date instances (timestamp NaN) to undefined, ensuring that
+ * malformed or unparsable date values do not propagate through normalization.
+ */
+export declare const invalidDateToUndefined: NormalizationRule<unknown>;

package/dist/core/normalizers/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ----------------------------------------------------------------------------
+ *  Normalizers | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Re‑exports all normalization rules, providing a single,
+ *                  consolidated entry point for the normalization subsystem.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export { compactSparseArray } from './array/compact-sparse-array';
+export { flattenOneLevel } from './array/flatten-one-level';
+export { removeEmptyStringItems } from './array/remove-empty-string-items';
+export { removeNullItems } from './array/remove-null-items';
+export { removeUndefinedItems } from './array/remove-undefined-items';
+export { invalidDateToUndefined } from './date/invalid-date-to-undefined';
+export { infinityToUndefined } from './number/infinity-to-undefined';
+export { nanToUndefined } from './number/nan-to-undefined';
+export { normalizeNegativeZero } from './number/normalize-negative-zero';
+export { removeEmptyArrayKeys } from './object/remove-empty-array-keys';
+export { removeEmptyObjectKeys } from './object/remove-empty-object-keys';
+export { removeEmptyStringKeys } from './object/remove-empty-string-keys';
+export { removeNullKeys } from './object/remove-null-keys';
+export { removeUndefinedKeys } from './object/remove-undefined-keys';
+export { collapseWhitespace } from './string/collapse-whitespace';
+export { emptyToUndefined } from './string/empty-to-undefined';
+export { trim } from './string/trim';
+export { normalizationRuleRegistry } from './normalizer-register';

package/dist/core/normalizers/normalizer-register.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule, StructuralType } from '../shapes';
+/**
+ * Maps each structural type to the normalization rules that apply to it,
+ * defining the full normalization pipeline Jane runs for incoming values.
+ */
+export declare const normalizationRuleRegistry: Record<StructuralType, readonly NormalizationRule[]>;

package/dist/core/normalizers/number/infinity-to-undefined.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Converts `Infinity` and `-Infinity` to `undefined`, removing non‑finite
+ * numeric values that cannot be represented safely across serialization or
+ * downstream validation.
+ */
+export declare const infinityToUndefined: NormalizationRule<unknown>;

package/dist/core/normalizers/number/nan-to-undefined.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Converts `NaN` to `undefined`, eliminating invalid numeric states that cannot
+ * be meaningfully compared, serialized, or validated.
+ */
+export declare const nanToUndefined: NormalizationRule<unknown>;

package/dist/core/normalizers/number/normalize-negative-zero.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Normalizes `-0` to `0`, removing a JavaScript‑specific numeric edge case
+ * while preserving the value’s intended semantics.
+ */
+export declare const normalizeNegativeZero: NormalizationRule<unknown>;

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

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Removes keys whose values are empty arrays, eliminating structurally empty
+ * list fields while preserving all non‑empty array values.
+ */
+export declare const removeEmptyArrayKeys: NormalizationRule<unknown>;

package/dist/core/normalizers/object/remove-empty-object-keys.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Removes keys whose values are empty plain objects, filtering out fields that
+ * carry no structural or semantic content.
+ */
+export declare const removeEmptyObjectKeys: NormalizationRule<unknown>;

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

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Removes keys whose values are empty strings, clearing out placeholder or
+ * accidental text fields while retaining all meaningful values.
+ */
+export declare const removeEmptyStringKeys: NormalizationRule<unknown>;

package/dist/core/normalizers/object/remove-null-keys.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Removes keys whose values are null, eliminating explicitly empty fields while
+ * preserving all defined data.
+ */
+export declare const removeNullKeys: NormalizationRule<unknown>;

package/dist/core/normalizers/object/remove-undefined-keys.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Removes keys whose values are undefined, producing a cleaner and more
+ * predictable object shape by stripping absent fields.
+ */
+export declare const removeUndefinedKeys: NormalizationRule<unknown>;

package/dist/core/normalizers/string/collapse-whitespace.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Collapses repeated internal whitespace into a single space, producing a
+ * cleaner and more consistent text structure without altering meaning.
+ */
+export declare const collapseWhitespace: NormalizationRule<unknown>;

package/dist/core/normalizers/string/empty-to-undefined.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Converts empty strings to undefined, removing text fields that contain no
+ * meaningful content.
+ */
+export declare const emptyToUndefined: NormalizationRule<unknown>;

package/dist/core/normalizers/string/trim.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { NormalizationRule } from '../../shapes';
+/**
+ * Trims leading and trailing whitespace, normalizing text edges while
+ * preserving the internal content exactly as provided.
+ */
+export declare const trim: NormalizationRule<unknown>;

package/dist/core/parsers/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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
+ * ----------------------------------------------------------------------------
+ */
+export { parseArrayString } from './parse-array-string';
+export { parseJsonString } from './parse-json-string';
+export { parseBigIntString } from './parse-bigint-string';
+export { parseBinaryString } from './parse-binary-string';
+export { parseHexString } from './parse-hex-string';
+export { parseOctalString } from './parse-octal-string';
+export { parseBooleanString } from './parse-boolean-string';
+export { parseIsoDateString } from './parse-date-string';
+export { parseDurationString } from './parse-duration-string';
+export { parseNumericString } from './parse-numeric-string';
+export { parseObjectString } from './parse-object-string';
+export { parseUrlString } from './parse-url-string';

package/dist/core/parsers/parse-array-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { ParseRule } from '../shapes';
+/**
+ * Parses JSON‑compatible array strings into actual arrays, rejecting anything
+ * that is not a syntactically valid array literal.
+ */
+export declare const parseArrayString: ParseRule<unknown>;

package/dist/core/parsers/parse-bigint-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { ParseRule } from '../shapes';
+/**
+ * Parses canonical decimal bigint strings into `bigint` values, enforcing a
+ * strict digits‑only format with an optional leading minus.
+ */
+export declare const parseBigIntString: ParseRule<unknown>;

package/dist/core/parsers/parse-binary-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { ParseRule } from '../shapes';
+/**
+ * Parses binary string literals (`0b…`) into `bigint` values, validating format
+ * and rejecting malformed or non‑binary input.
+ */
+export declare const parseBinaryString: ParseRule<unknown>;

package/dist/core/parsers/parse-boolean-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { ParseRule } from '../shapes';
+/**
+ * Parses strict boolean strings (`"true"` or `"false"`) into boolean values,
+ * without accepting loose or coercive forms.
+ */
+export declare const parseBooleanString: ParseRule<unknown>;

package/dist/core/parsers/parse-date-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse ISO Date String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict ISO‑8601 date strings into `Date` objects,
+ *                  rejecting malformed or non‑standard formats.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses strict ISO‑8601 date strings into `Date` objects, rejecting malformed
+ * or non‑standard formats and ensuring the resulting timestamp is valid.
+ */
+export declare const parseIsoDateString: ParseRule<unknown>;

package/dist/core/parsers/parse-duration-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Duration String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses duration strings of the form `<number><unit>` (s, m,
+ *                  h, d) into structured duration objects.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses duration strings of the form `<number><unit>` (s, m, h, d) into
+ * structured duration objects, rejecting ambiguous or partial formats.
+ */
+export declare const parseDurationString: ParseRule<unknown>;

package/dist/core/parsers/parse-hex-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Hex String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses hexadecimal string literals (0x…) into `bigint`
+ *                  values, enforcing canonical formatting.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses hexadecimal string literals (`0x…`) into numeric values, rejecting
+ * malformed or non‑hexadecimal input.
+ */
+export declare const parseHexString: ParseRule<unknown>;

package/dist/core/parsers/parse-integer-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Integer String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict integer strings into numeric values, rejecting
+ *                  floats, scientific notation, and ambiguous formats.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses strict integer strings into numeric values, rejecting floats,
+ * scientific notation, and any non‑digit characters.
+ */
+export declare const parseIntegerString: ParseRule<unknown>;

package/dist/core/parsers/parse-json-string.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse JSON String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses JSON‑compatible strings into structured data,
+ *                  accepting only valid objects, arrays, or quoted strings.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses JSON‑compatible strings into structured data, accepting only objects,
+ * arrays, or quoted strings and rejecting anything that cannot be parsed
+ * safely.
+ */
+export declare const parseJsonString: ParseRule<unknown>;

package/dist/core/parsers/parse-numeric-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Numeric String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict numeric strings into numbers, supporting
+ *                  optional decimals while rejecting ambiguous formats.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses strict numeric strings into JavaScript numbers, supporting optional
+ * decimals while rejecting scientific notation and non‑numeric characters.
+ */
+export declare const parseNumericString: ParseRule<unknown>;

package/dist/core/parsers/parse-object-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Object String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses JSON object strings into plain objects, rejecting
+ *                  arrays, null, and non‑object structures.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses JSON object strings into plain objects, rejecting arrays, null, and
+ * any non‑object structures.
+ */
+export declare const parseObjectString: ParseRule<unknown>;

package/dist/core/parsers/parse-octal-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Octal String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses octal string literals (`0o…`) into `bigint` values,
+ *                  enforcing strict base‑8 formatting.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses octal string literals (`0o…`) into `bigint` values, validating format
+ * and rejecting malformed or non‑octal input.
+ */
+export declare const parseOctalString: ParseRule<unknown>;

package/dist/core/parsers/parse-scientific-notation-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse Scientific Notation String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses strict scientific‑notation strings into numbers,
+ *                  validating both mantissa and exponent format.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses strict scientific‑notation strings into numbers, enforcing canonical
+ * formatting for both mantissa and exponent.
+ */
+export declare const parseScientificNotationString: ParseRule<unknown>;

package/dist/core/parsers/parse-url-string.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Parsers | Parse URL String
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Parses URL strings into normalized URL values, ensuring the
+ *                  text represents a valid, fully qualified URL.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ParseRule } from '../shapes';
+/**
+ * Parses URL strings into normalized URL values, ensuring the text represents
+ * a syntactically valid and fully qualified URL.
+ */
+export declare const parseUrlString: ParseRule<string>;