rip-lang 3.13.26 → 3.13.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.13.26",
+  "version": "3.13.28",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",

package/src/app.rip

@@ -757,7 +757,7 @@ export createRenderer = (opts = {}) ->
           inst.mount wrapper
           layoutInstances.push inst
 
-          slot = wrapper.querySelector('#content') or wrapper
+          slot = wrapper.querySelector('slot') or wrapper
           mp = slot
 
         currentLayouts = [...layoutFiles]

package/src/compiler.js

@@ -205,6 +205,7 @@ export class CodeGenerator {
     'continue': 'generateContinue',
     '?': 'generateExistential',
     'defined': 'generateDefined',
+    'presence': 'generatePresence',
     '?:': 'generateTernary',
     '|>': 'generatePipe',
     'loop': 'generateLoop',
@@ -941,17 +942,38 @@ export class CodeGenerator {
       let isIncl = index[0] === '..';
       let arrCode = this.generate(arr, 'value');
       let [start, end] = index.slice(1);
+
+      // Detect compile-time numeric literals (positive, negative, String objects)
+      let numericLiteral = (node) => {
+        if (node === null) return null;
+        let v = str(node) ?? node;
+        if (typeof v === 'number') return v;
+        if ((typeof v === 'string') && /^\d+$/.test(v)) return +v;
+        if (Array.isArray(node) && node[0] === '-' && node.length === 2) {
+          let inner = str(node[1]) ?? node[1];
+          if (typeof inner === 'number') return -inner;
+          if ((typeof inner === 'string') && /^\d+$/.test(inner)) return -inner;
+        }
+        return null;
+      };
+
+      let inclEnd = (s, e, endNode) => {
+        let n = numericLiteral(endNode);
+        if (n !== null && n !== -1) return `${arrCode}.slice(${s}, ${n + 1})`;
+        return `${arrCode}.slice(${s}, +${e} + 1 || 9e9)`;
+      };
+
       if (start === null && end === null) return `${arrCode}.slice()`;
       if (start === null) {
         if (isIncl && this.is(end, '-', 1) && (str(end[1]) ?? end[1]) == 1) return `${arrCode}.slice(0)`;
         let e = this.generate(end, 'value');
-        return isIncl ? `${arrCode}.slice(0, +${e} + 1 || 9e9)` : `${arrCode}.slice(0, ${e})`;
+        return isIncl ? inclEnd('0', e, end) : `${arrCode}.slice(0, ${e})`;
       }
       if (end === null) return `${arrCode}.slice(${this.generate(start, 'value')})`;
       let s = this.generate(start, 'value');
       if (isIncl && this.is(end, '-', 1) && (str(end[1]) ?? end[1]) == 1) return `${arrCode}.slice(${s})`;
       let e = this.generate(end, 'value');
-      return isIncl ? `${arrCode}.slice(${s}, +${e} + 1 || 9e9)` : `${arrCode}.slice(${s}, ${e})`;
+      return isIncl ? inclEnd(s, e, end) : `${arrCode}.slice(${s}, ${e})`;
     }
     // Negative literal index: arr[-1] → arr.at(-1)
     if (this.is(index, '-', 1)) {
@@ -1124,6 +1146,10 @@ export class CodeGenerator {
     return `(${this.generate(rest[0], 'value')} !== undefined)`;
   }
 
+  generatePresence(head, rest) {
+    return `(${this.generate(rest[0], 'value')} ? true : undefined)`;
+  }
+
   generateTernary(head, rest, context) {
     let [cond, then_, else_] = rest;
 

package/src/components.js

@@ -289,9 +289,14 @@ export function installComponentSupport(CodeGenerator, Lexer) {
         let prevTag = prevToken ? prevToken[0] : null;
         if (prevTag === 'INDENT' || prevTag === 'TERMINATOR') {
           if (nextToken && nextToken[0] === 'PROPERTY') {
-            let divToken = gen('IDENTIFIER', 'div', token);
-            tokens.splice(i, 0, divToken);
-            return 2;
+            // Check if property is followed by : — if so, it's an attribute
+            // (. foo: bar → div foo: bar), not a class (. foo → div.foo)
+            let nextNext = i + 2 < tokens.length ? tokens[i + 2] : null;
+            if (!nextNext || nextNext[0] !== ':') {
+              let divToken = gen('IDENTIFIER', 'div', token);
+              tokens.splice(i, 0, divToken);
+              return 2;
+            }
           }
           // Skip .('classes') — handled by dynamic classes handler below
           if (!nextToken || nextToken[0] !== '(') {
@@ -1041,19 +1046,26 @@ export function installComponentSupport(CodeGenerator, Lexer) {
         this.generateAttributes(elVar, arg);
       }
       else if (typeof arg === 'string' || arg instanceof String) {
-        const textVar = this.newTextVar();
         const val = arg.valueOf();
-        if (val.startsWith('"') || val.startsWith("'") || val.startsWith('`')) {
-          this._createLines.push(`${textVar} = document.createTextNode(${val});`);
-        } else if (this.reactiveMembers && this.reactiveMembers.has(val)) {
-          this._createLines.push(`${textVar} = document.createTextNode('');`);
-          this._pushEffect(`${textVar}.data = ${this._self}.${val}.value;`);
-        } else if (this.componentMembers && this.componentMembers.has(val)) {
-          this._createLines.push(`${textVar} = document.createTextNode(String(${this._self}.${val}));`);
+        // Template tag appearing as a string arg (e.g., slot after multi-line attrs)
+        const [tagPart, idPart] = val.split('#');
+        if (this.isHtmlTag(tagPart || 'div') || this.isComponent(val)) {
+          const childVar = this.generateNode(arg);
+          this._createLines.push(`${elVar}.appendChild(${childVar});`);
         } else {
-          this._createLines.push(`${textVar} = document.createTextNode(${this.generateInComponent(arg, 'value')});`);
+          const textVar = this.newTextVar();
+          if (val.startsWith('"') || val.startsWith("'") || val.startsWith('`')) {
+            this._createLines.push(`${textVar} = document.createTextNode(${val});`);
+          } else if (this.reactiveMembers && this.reactiveMembers.has(val)) {
+            this._createLines.push(`${textVar} = document.createTextNode('');`);
+            this._pushEffect(`${textVar}.data = ${this._self}.${val}.value;`);
+          } else if (this.componentMembers && this.componentMembers.has(val)) {
+            this._createLines.push(`${textVar} = document.createTextNode(String(${this._self}.${val}));`);
+          } else {
+            this._createLines.push(`${textVar} = document.createTextNode(${this.generateInComponent(arg, 'value')});`);
+          }
+          this._createLines.push(`${elVar}.appendChild(${textVar});`);
         }
-        this._createLines.push(`${elVar}.appendChild(${textVar});`);
       }
       else if (arg) {
         const childVar = this.generateNode(arg);

package/src/grammar/grammar.rip

@@ -853,6 +853,9 @@ grammar =
     # Postfix defined check: expr!? → (expr !== undefined)
     o 'Value DEFINED'         , '["defined", 1]'
 
+    # Postfix presence check: expr?! → (expr ? true : undefined) — Houdini operator
+    o 'Value PRESENCE'        , '["presence", 1]'
+
     # Await
     o 'AWAIT Expression'            , '["await", 2]'
     o 'AWAIT INDENT Object OUTDENT' , '["await", 3]'
@@ -895,7 +898,7 @@ grammar =
     o 'Expression RELATION Expression', '[2, 1, 3]'     # in, of, instanceof
 
     # Ternary
-    o 'Expression SPACE? Expression : Expression', '["?:", 1, 3, 5]'
+    o 'Expression TERNARY Expression : Expression', '["?:", 1, 3, 5]'
 
     # Compound assignment
     o 'SimpleAssignable COMPOUND_ASSIGN Expression'               , '[2, 1, 3]'
@@ -916,7 +919,7 @@ operators = """
   right       DO_IIFE
   left        . ?.
   left        CALL_START CALL_END
-  nonassoc    ++ -- ? DEFINED
+  nonassoc    ++ -- ? DEFINED PRESENCE
   right       UNARY DO
   right       AWAIT
   right       **
@@ -932,7 +935,7 @@ operators = """
   left        &&
   left        ||
   left        PIPE
-  right       SPACE?
+  right       TERNARY
   nonassoc    INDENT OUTDENT
   right       YIELD
   right       = : COMPOUND_ASSIGN RETURN THROW EXTENDS

package/src/lexer.js

@@ -180,7 +180,7 @@ let CALL_CLOSERS = new Set(['.', '?.']);
 let UNFINISHED = new Set([
   '\\', '.', '?.', 'UNARY', 'DO', 'DO_IIFE',
   'MATH', 'UNARY_MATH', '+', '-', '**', 'SHIFT', 'RELATION',
-  'COMPARE', '&', '^', '|', '&&', '||', 'SPACE?', 'EXTENDS',
+  'COMPARE', '&', '^', '|', '&&', '||', 'TERNARY', 'EXTENDS',
 ]);
 
 // Tokens that are not followed by regex (division context)
@@ -209,12 +209,12 @@ let UNARY_MATH = new Set(['!', '~']);
 // ==========================================================================
 
 // Identifier: word chars + optional trailing ! (await) or ? (predicate)
-// The ? suffix is only captured when NOT followed by . ? [ ( to avoid
-// conflict with ?. (optional chaining), ?? (nullish), ?.( and ?.[
+// The ? suffix is only captured when NOT followed by . ? ! [ ( to avoid
+// conflict with ?. (optional chaining), ?? (nullish), ?! (presence), ?.( and ?.[
 // The ! suffix is NOT captured when followed by ? to preserve !? as operator
-let IDENTIFIER_RE = /^(?!\d)((?:(?!\s)[$\w\x7f-\uffff])+(?:!(?!\?)|[?](?![.?[(]))?)([^\n\S]*:(?![=:]))?/;
+let IDENTIFIER_RE = /^(?!\d)((?:(?!\s)[$\w\x7f-\uffff])+(?:!(?!\?)|[?](?![.?![(]))?)([^\n\S]*:(?![=:]))?/;
 let NUMBER_RE     = /^0b[01](?:_?[01])*n?|^0o[0-7](?:_?[0-7])*n?|^0x[\da-f](?:_?[\da-f])*n?|^\d+(?:_\d+)*n|^(?:\d+(?:_\d+)*)?\.?\d+(?:_\d+)*(?:e[+-]?\d+(?:_\d+)*)?/i;
-let OPERATOR_RE   = /^(?:<=>|::=|::|[-=]>|~>|~=|:=|=!|===|!==|!\?|\?\?|=~|\|>|[-+*\/%<>&|^!?=]=|>>>=?|([-+:])\1|([&|<>*\/%])\2=?|\?\.?|\.{2,3})/;
+let OPERATOR_RE   = /^(?:<=>|::=|::|[-=]>|~>|~=|:=|=!|===|!==|!\?|\?\!|\?\?|=~|\|>|[-+*\/%<>&|^!?=]=|>>>=?|([-+:])\1|([&|<>*\/%])\2=?|\?\.?|\.{2,3})/;
 let WHITESPACE_RE = /^[^\n\S]+/;
 let NEWLINE_RE    = /^(?:\n[^\n\S]*)+/;
 let COMMENT_RE    = /^(\s*)###([^#][\s\S]*?)(?:###([^\n\S]*)|###$)|^((?:\s*#(?!##[^#]).*)+)/;
@@ -500,7 +500,7 @@ export class Lexer {
     let prev = this.prev();
 
     // Don't treat colon as property when in ternary context
-    if (colon && prev && prev[0] === 'SPACE?') colon = null;
+    if (colon && prev && prev[0] === 'TERNARY') colon = null;
 
     // Property vs identifier
     if (colon || (prev && (prev[0] === '.' || prev[0] === '?.' || (!prev.spaced && prev[0] === '@')))) {
@@ -634,7 +634,10 @@ export class Lexer {
         if (prev && (prev[0] === 'IDENTIFIER' || prev[0] === 'PROPERTY'))
           return 0;  // after a tag (div#main) → let # become a token for rewriter
         let m = /^#([a-zA-Z_][\w-]*)/.exec(this.chunk);
-        if (m) { this.emit('IDENTIFIER', 'div#' + m[1]); return m[0].length; }
+        if (m) {
+          this.emit('IDENTIFIER', m[1] === 'content' ? 'slot' : 'div#' + m[1]);
+          return m[0].length;
+        }
       }
       if (/^\s+#[a-zA-Z_]/.test(this.chunk)) return 0;  // let lineToken handle indentation first
     }
@@ -1225,10 +1228,12 @@ export class Lexer {
     else if (COMPOUND_ASSIGN.has(val)) tag = 'COMPOUND_ASSIGN';
     else if (UNARY_MATH.has(val))      tag = 'UNARY_MATH';
     else if (SHIFT.has(val))           tag = 'SHIFT';
-    // Spaced ? → SPACE? (ternary)
-    else if (val === '?' && prev?.spaced) tag = 'SPACE?';
+    // Spaced ? → TERNARY (ternary)
+    else if (val === '?' && prev?.spaced) tag = 'TERNARY';
     // Unspaced !? → DEFINED (postfix defined check: v!? → v !== undefined)
     else if (val === '!?' && prev && !prev.spaced) tag = 'DEFINED';
+    // Unspaced ?! → PRESENCE (Houdini: v?! → v ? true : undefined)
+    else if (val === '?!' && prev && !prev.spaced) tag = 'PRESENCE';
     // ?[ and ?( without dot → treat as optional chaining (?.)
     else if (val === '?' && (this.chunk[1] === '[' || this.chunk[1] === '(')) tag = '?.';
     // Call/index context (ES6 optional chaining only)
@@ -1529,7 +1534,7 @@ export class Lexer {
       }
 
       // Track ternary
-      if (tag === 'SPACE?') inTernary = true;
+      if (tag === 'TERNARY') inTernary = true;
 
       // Implicit objects start at ':'
       if (tag === ':') {