tricu

literal-input.ts (4752B)

---

 import { literals, type Literal } from './codecs.js';
 
 // Deliberately a data-only subset, not a second source compiler. No names,
 // arbitrary applications, comments, or effects are evaluated in argument fields.
 export function parseLiteral(source: string): Literal {
   if (source.length > 16_000) throw new Error('Argument text limit exceeded');
   let at = 0, items = 0;
   const space = () => { while (source[at] === ' ' || source[at] === '\n') at++; };
   const fail = (): never => { throw new Error(`Expected a literal at character ${at + 1}`); };
   function atom(depth: number): Literal {
     if (++items > 4096 || depth > 16) throw new Error('Literal nesting/item limit exceeded');
     space(); const start = at, token = source[at++];
     if (token === '"') {
       let value = '';
       while (at < source.length) {
         const char = source[at++];
         if (char === '"') {
           const scalars = Array.from(value);
           if (scalars.length > 4096 || scalars.some(c => { const n = c.codePointAt(0)!; return n >= 0xd800 && n <= 0xdfff; }))
             throw new Error('Expected bounded Unicode scalar text');
           return { type: 'string', value };
         }
         if (char === '\\') {
           const escapes: Record<string, string> = { n: '\n', t: '\t', r: '\r', f: '\f', b: '\b', '\\': '\\', '"': '"', "'": "'" };
           const escaped = escapes[source[at++]!]; if (escaped === undefined) fail(); value += escaped;
         } else value += char;
       }
       fail();
     }
     if (token === '[') {
       const value: Literal[] = []; space();
       while (source[at] !== ']') { if (at >= source.length) fail(); value.push(atom(depth + 1)); space(); }
       at++; return { type: 'list', value };
     }
     if (token === '(') { const value = expression(depth + 1); space(); if (source[at++] !== ')') fail(); return value; }
     if (token === 't') return { type: 'tree', value: '0' };
     if (token && /[0-9]/u.test(token)) {
       while (source[at] && /[0-9]/u.test(source[at]!)) at++;
       return literals([{ type: 'number', value: source.slice(start, at).replace(/^0+(?=\d)/u, '') }])[0]!;
     }
     return fail();
   }
   function expression(depth: number): Literal {
     space(); const constructor = source[at] === 't'; const first = atom(depth);
     if (!constructor) return first;
     const children: Literal[] = []; space();
     while (at < source.length && source[at] !== ')' && source[at] !== ']') {
       if (children.length === 2) fail(); children.push(atom(depth + 1)); space();
     }
     // Constructor children can contain encoded scalar/list data without evaluation.
     const ternary = (literal: Literal): string => {
       switch (literal.type) {
         case 'tree': return literal.value;
         case 'bool': return literal.value ? '10' : '0';
         case 'number': {
           let n = BigInt(literal.value), result = '';
           while (n) { result += n & 1n ? '210' : '20'; n >>= 1n; }
           return result + '0';
         }
         case 'string': return ternary({ type: 'list', value: Array.from(literal.value).map(c => ({ type: 'number', value: String(c.codePointAt(0)) })) });
         case 'bytes': return ternary({ type: 'list', value: literal.value.map(n => ({ type: 'number', value: String(n) })) });
         case 'list': return literal.value.map(v => '2' + ternary(v)).join('') + '0';
       }
     };
     const value = String(children.length) + children.map(ternary).join('');
     if (value.length > 8192) throw new Error('Tree literal limit exceeded');
     return { type: 'tree', value };
   }
   const value = expression(0); space(); if (at !== source.length) fail();
   return literals([value])[0]!;
 }
 
 export function printLiteral(literal: Literal): string {
   switch (literal.type) {
     case 'number': return literal.value;
     case 'string': return '"' + literal.value.replace(/[\\"\n\t\r\f\b]/gu, c => ({ '\\': '\\\\', '"': '\\"', '\n': '\\n', '\t': '\\t', '\r': '\\r', '\f': '\\f', '\b': '\\b' })[c]!) + '"';
     case 'bool': return literal.value ? '(t t)' : 't';
     case 'bytes': return '[' + literal.value.join(' ') + ']';
     case 'list': return '[' + literal.value.map(printLiteral).join(' ') + ']';
     case 'tree': {
       let at = 0; const value = literal.value;
       function read(depth: number): string {
         if (depth > 16) throw new Error('Use raw JSON for deeply nested trees');
         const tag = value[at++];
         if (tag === '0') return 't';
         if (tag === '1') return `(t ${read(depth + 1)})`;
         if (tag === '2') return `(t ${read(depth + 1)} ${read(depth + 1)})`;
         throw new Error('Invalid ternary tree');
       }
       const result = read(0); if (at !== literal.value.length) throw new Error('Trailing ternary data'); return result;
     }
   }
 }