functionalscript 0.3.12 → 0.3.14

package/bnf/module.f.d.ts

@@ -1,135 +0,0 @@
-/**
- *  Types for defining language grammars using Backus-Naur Form (BNF).
- *
- * @module
- *
- * @description
- *
- * The primary utility of this module is to define grammars for text processing,
- * parsing, and lexing in a structured and reusable way.
- *
- * See [Backus-Naur form](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form).
- *
- * @example
- *
- * ```js
- * import { firstSet, type Rule, type Set } from './module.f.ts'
- *
- * const grammar: Rule = [
- *     { or: [[65, 90], [97, 122], [48, 57]] }, // Matches 'A-Z', 'a-z', and '0-9'
- * ];
- *
- * const s = firstSet(grammar)
- * if (s.empty) { throw s }
- * if (setOp.get('0'.codePointAt(0))(s.map) !== true) { throw s }
- * if (setOp.get('h'.codePointAt(0))(s.map) !== true) { throw s }
- * if (setOp.get('$'.codePointAt(0))(s.map) !== false) { throw s }
- * ```
- */
-import { type CodePoint } from '../text/utf16/module.f.ts';
-import { type RangeMapOp, type RangeMapArray } from '../types/range_map/module.f.ts';
-/**
- * Represents a terminal range as a pair of Unicode code points.
- * Typically used to define character ranges.
- *
- * @example
- *
- * ```ts
- * const alpha: TerminalRange = [65, 90] // Matches 'A-Z'
- * ```
- */
-export type TerminalRange = readonly [CodePoint, CodePoint];
-/**
- * Represents a sequence of rules that must match in order.
- *
- * @example
- *
- * ```ts
- * const alpha: TerminalRange = [65, 90] // Matches 'A-Z'
- * const id2: Sequence = [alpha, alpha]  // Matches two uppercase letters
- * ```
- */
-export type Sequence = readonly Rule[];
-/**
- * Represents a logical "or" operation between multiple sequences.
- * Allows defining alternatives within the grammar.
- *
- * @example
- *
- * ```ts
- * const alpha: TerminalRange = [65, 90] // Matches 'A-Z'
- * const id2: Sequence = [alpha, alpha]  // Matches two uppercase letters
- * const digit: TerminalRange = [48, 57] // Matches '0-9'
- * // Matches two uppercase letters or one digit
- * const id2OrDigit: Or = { or: [
- *     id2,
- *     digit,
- * ] }
- * ```
- */
-export type Or = {
-    readonly or: Sequence;
-};
-/**
- * Represents a grammar rule, which can be:
- * - A sequence of rules (`Sequence`)
- * - An "or" operation (`Or`)
- * - A terminal range (`TerminalRange`)
- * - A string (representing a literal sequence of characters)
- *
- * @remarks The rule can't have recursions.
- *
- * @example
- *
- * ```ts
- * // Matches 'true', 'false'
- * const bool: DataRule = { or: [
- *    'true',
- *    'false',
- * ] }
- */
-export type DataRule = Or | Sequence | TerminalRange | string;
-/**
- * Represents a lazy grammar rule for recursive definitions.
- *
- * @example
- *
- * ```ts
- * const alpha: TerminalRange = [65, 90]  // Matches 'A-Z'
- * // Matches a string of uppercase letters
- * const id: LazyRule = () => [alpha, { or: [
- *     [],  // Empty
- *     id   // Recursive
- * ] }]
- * ```
- */
-export type LazyRule = () => DataRule;
-/**
- * Represents a rule in the grammar.
- */
-export type Rule = DataRule | LazyRule;
-export declare const toTerminalRangeSequence: (s: string) => readonly TerminalRange[];
-/**
- * A set that represents possible code points.
- */
-export type CpSet = {
-    /**
-     * Whether a grammar rule allows an empty sequence.
-     */
-    readonly empty: boolean;
-    /**
-     * The range map representing a set of possible code points.
-     */
-    readonly map: RangeMapArray<boolean>;
-};
-/**
- * Operations on code point sets.
- */
-export declare const setOp: RangeMapOp<boolean>;
-/**
- * Processes a `Rule` and converts it into a `Set` of possible code points at the start of the rule.
- *
- * @param rule - The grammar rule to process.
- * @returns A set representing the first possible code points in the grammar rule.
- */
-export declare const firstSet: (rule: Rule) => CpSet;

package/bnf/module.f.js

@@ -1,142 +0,0 @@
-/**
- *  Types for defining language grammars using Backus-Naur Form (BNF).
- *
- * @module
- *
- * @description
- *
- * The primary utility of this module is to define grammars for text processing,
- * parsing, and lexing in a structured and reusable way.
- *
- * See [Backus-Naur form](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form).
- *
- * @example
- *
- * ```js
- * import { firstSet, type Rule, type Set } from './module.f.ts'
- *
- * const grammar: Rule = [
- *     { or: [[65, 90], [97, 122], [48, 57]] }, // Matches 'A-Z', 'a-z', and '0-9'
- * ];
- *
- * const s = firstSet(grammar)
- * if (s.empty) { throw s }
- * if (setOp.get('0'.codePointAt(0))(s.map) !== true) { throw s }
- * if (setOp.get('h'.codePointAt(0))(s.map) !== true) { throw s }
- * if (setOp.get('$'.codePointAt(0))(s.map) !== false) { throw s }
- * ```
- */
-import { stringToCodePointList } from "../text/utf16/module.f.js";
-import { map, toArray } from "../types/list/module.f.js";
-import { rangeMap } from "../types/range_map/module.f.js";
-const toTerminalRangeMap = map((cp) => [cp, cp]);
-export const toTerminalRangeSequence = (s) => toArray(toTerminalRangeMap(stringToCodePointList(s)));
-/**
- * Operations on code point sets.
- */
-export const setOp = rangeMap({
-    union: a => b => a || b,
-    equal: a => b => a === b,
-    def: false
-});
-const { merge, fromRange } = setOp;
-const rangeToSet = (r) => ({ empty: false, map: fromRange(r)(true) });
-const isTerminalRange = (rule) => typeof rule[0] === 'number';
-const passSet = { empty: true, map: [] };
-/**
- * Processes a `Rule` and converts it into a `Set` of possible code points at the start of the rule.
- *
- * @param rule - The grammar rule to process.
- * @returns A set representing the first possible code points in the grammar rule.
- */
-export const firstSet = (rule) => {
-    if (typeof rule === 'function') {
-        rule = rule();
-    }
-    if (typeof rule === 'string') {
-        const first = toTerminalRangeSequence(rule).at(0);
-        if (first === undefined) {
-            return passSet;
-        }
-        return rangeToSet(first);
-    }
-    if (rule instanceof Array) {
-        if (isTerminalRange(rule)) {
-            return rangeToSet(rule);
-        }
-        let result = [];
-        for (const r of rule) {
-            const { empty, map } = firstSet(r);
-            result = toArray(merge(result)(map));
-            if (!empty) {
-                return { empty: false, map: result };
-            }
-        }
-        return { empty: true, map: result };
-    }
-    let empty = false;
-    let map = [];
-    for (const r of rule.or) {
-        const { empty: rEmpty, map: rMap } = firstSet(r);
-        map = toArray(merge(map)(rMap));
-        empty ||= rEmpty;
-    }
-    return { empty, map };
-};
-// type MatchMap = {
-//     empty: boolean
-//     map: RangeMapArray<MatchMap>
-// }
-// const defMatchMap: MatchMap = { empty: false, map: [] }
-// const unionMap = (a: MatchMap) => (b: MatchMap) =>
-//     ({ empty: a.empty || b.empty, map: toArray(matchMapOp.merge(a.map)(b.map)) })
-// /**
-//  * Operations on code point map.
-//  */
-// const matchMapOp: RangeMapOp<MatchMap> = rangeMap({
-//     union: unionMap,
-//     equal: a => b => a === b,
-//     def: defMatchMap
-// })
-// const { merge: mergeMap, fromRange: fromRangeMap } = matchMapOp
-// const pass: MatchMap = { empty: true, map: [] }
-// const rangeToMatchMap = (r: TerminalRange, p: MatchMap): MatchMap => ({ empty: false, map: fromRangeMap(r)(p) })
-// /**
-//  * Processes a `Rule` and converts it into a `Set` of possible code points at the start of the rule.
-//  *
-//  * @param rule - The grammar rule to process.
-//  * @returns A set representing the first possible code points in the grammar rule.
-//  */
-// export const matchMap = (rule: Rule): MatchMap => {
-//     if (typeof rule === 'function') {
-//         rule = rule()
-//     }
-//     if (typeof rule === 'string') {
-//         const a = toTerminalRangeSequence(rule)
-//         let result = pass
-//         for (const r of a) {
-//             result = rangeToMatchMap(r, result)
-//         }
-//         return result
-//     }
-//     if (rule instanceof Array) {
-//         if (isTerminalRange(rule)) {
-//             return rangeToMatchMap(rule, pass)
-//         }
-//         let result = pass
-//         for (const r of rule.toReversed()) {
-//             todo()
-//             /*
-//             const rMap = matchMap(r)
-//             result = unionMap(result)(rMap)
-//             */
-//         }
-//         return result
-//     }
-//     let result = pass
-//     for (const r of rule.or) {
-//         const rMap = matchMap(r)
-//         result = unionMap(result)(rMap)
-//     }
-//     return result
-// }

package/bnf/test.f.d.ts

@@ -1,65 +0,0 @@
-declare const _default: {
-    example: {
-        module: () => void;
-        types: () => void;
-    };
-    classic: () => {
-        ws: () => void;
-        sign: () => void;
-        digits: () => void;
-        exponent: () => void;
-        fraction: () => void;
-        onenine: () => void;
-        digit: () => void;
-        string: () => void;
-        member: () => void;
-        members: () => void;
-        object: () => void;
-        array: () => void;
-        integer: () => void;
-        number: () => void;
-        value: () => void;
-        element: () => void;
-        elements: () => void;
-        json: () => void;
-        hex: () => void;
-        escape: () => void;
-        character: () => void;
-        characters: () => void;
-    };
-    deterministic: () => {
-        ws: () => void;
-        sign: () => void;
-        digits1: () => void;
-        digits: () => void;
-        exponent: () => void;
-        fraction: () => void;
-        onenine: () => void;
-        digit: () => void;
-        string: () => void;
-        member1: () => void;
-        member: () => void;
-        members2: () => void;
-        members1: () => void;
-        members: () => void;
-        object1: () => void;
-        object: () => void;
-        array1: () => void;
-        array: () => void;
-        integer1: () => void;
-        integer: () => void;
-        number: () => void;
-        value: () => void;
-        element1: () => void;
-        element: () => void;
-        elements2: () => void;
-        elements1: () => void;
-        elements: () => void;
-        json: () => void;
-        hex: () => void;
-        escape: () => void;
-        character: () => void;
-        characters: () => void;
-    };
-};
-export default _default;