ripple 0.2.87 → 0.2.88

package/package.json

@@ -3,7 +3,7 @@
   "description": "Ripple is an elegant TypeScript UI framework",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.2.87",
+  "version": "0.2.88",
   "type": "module",
   "module": "src/runtime/index-client.js",
   "main": "src/runtime/index-client.js",

package/src/compiler/phases/1-parse/index.js

@@ -793,7 +793,36 @@ function RipplePlugin(config) {
 						this.next();
 					}
 				} else {
-					if (open.name.name === 'style') {
+					if (open.name.name === 'script') {
+						let content = '';
+
+						// TODO implement this where we get a string for content of the content of the script tag
+						// This is a temporary workaround to get the content of the script tag
+						const start = open.end;
+						const input = this.input.slice(start);
+						const end = input.indexOf('</script>');
+						content = input.slice(0, end);
+
+						const newLines = content.match(regex_newline_characters)?.length;
+						if (newLines) {
+							this.curLine = open.loc.end.line + newLines;
+							this.lineStart = start + content.lastIndexOf('\n') + 1;
+						}
+						this.pos = start + content.length + 1;
+
+						this.type = tok.jsxTagStart;
+						this.next();
+						if (this.value === '/') {
+							this.next();
+							this.jsx_parseElementName();
+							this.exprAllowed = true;
+							this.#path.pop();
+							this.next();
+						}
+
+						element.content = content;
+						this.finishNode(element, 'Element');
+					} else if (open.name.name === 'style') {
 						// jsx_parseOpeningElementAt treats ID selectors (ie. #myid) or type selectors (ie. div) as identifier and read it
 						// So backtrack to the end of the <style> tag to make sure everything is included
 						const start = open.end;

package/src/compiler/phases/2-analyze/index.js

@@ -488,7 +488,9 @@ const visitors = {
 					if (attr.name.type === 'Identifier') {
 						attribute_names.add(attr.name);
 					}
-					visit(attr.value, state);
+          if (attr.value !== null) {
+					  visit(attr.value, state);
+          }
 				} else if (attr.type === 'SpreadAttribute') {
 					visit(attr.argument, state);
 				} else if (attr.type === 'RefAttribute') {

package/src/compiler/phases/3-transform/client/index.js

@@ -137,12 +137,6 @@ function visit_title_element(node, context) {
 	}
 }
 
-function visit_style_element(node, context) {
-	context.state.template.push(
-		b.literal(`<style>${sanitize_template_string(node.css)}</style>`),
-	);
-}
-
 const visitors = {
 	_: function set_scope(node, { next, state }) {
 		const scope = state.scopes.get(node);
@@ -487,9 +481,19 @@ const visitors = {
 	Element(node, context) {
 		const { state, visit } = context;
 
-		if (context.state.inside_head && node.id.type === 'Identifier' && node.id.name === 'style') {
-			state.template.push(`<style>${sanitize_template_string(node.css)}</style>`);
-			return;
+		if (context.state.inside_head) {
+			if (node.id.type === 'Identifier' && node.id.name === 'style') {
+				state.template.push(`<style>${sanitize_template_string(node.css)}</style>`);
+				return;
+			}
+			if (node.id.type === 'Identifier' && node.id.name === 'script') {
+				const id = state.flush_node();
+				state.template.push('<!>');
+				context.state.init.push(
+					b.stmt(b.call('_$_.script', id, b.literal(sanitize_template_string(node.content)))),
+				);
+				return;
+			}
 		}
 
 		const is_dom_element = is_element_dom_element(node);
@@ -766,7 +770,8 @@ const visitors = {
 				if (attr.type === 'Attribute') {
 					if (attr.name.type === 'Identifier') {
 						const metadata = { tracking: false, await: false };
-						let property = visit(attr.value, { ...state, metadata });
+						let property =
+							attr.value === null ? b.literal(true) : visit(attr.value, { ...state, metadata });
 
 						if (metadata.tracking || attr.name.tracked) {
 							if (attr.name.name === 'children') {
@@ -1139,6 +1144,14 @@ const visitors = {
 		return context.next();
 	},
 
+	ExportNamedDeclaration(node, context) {
+		if (!context.state.to_ts && node.exportKind === 'type') {
+			return b.empty;
+		}
+
+		return context.next();
+	},
+
 	TryStatement(node, context) {
 		if (!is_inside_component(context)) {
 			context.next();

package/src/runtime/internal/client/for.js

@@ -17,29 +17,29 @@ import { array_from, is_array } from './utils.js';
  * @returns {Block}
  */
 function create_item(anchor, value, index, render_fn, is_indexed) {
-  var b = branch(() => {
-    var tracked_index;
-
-    if (is_indexed) {
-      var block = /** @type {Block} */ (active_block);
-
-      if (block.s === null) {
-        tracked_index = tracked(index, block);
-
-        block.s = {
-          start: null,
-          end: null,
-          i: tracked_index,
-        };
-      } else {
-        tracked_index = block.s.i;
-      }
-      render_fn(anchor, value, tracked_index);
-    } else {
-      render_fn(anchor, value);
-    }
-  });
-  return b;
+	var b = branch(() => {
+		var tracked_index;
+
+		if (is_indexed) {
+			var block = /** @type {Block} */ (active_block);
+
+			if (block.s === null) {
+				tracked_index = tracked(index, block);
+
+				block.s = {
+					start: null,
+					end: null,
+					i: tracked_index,
+				};
+			} else {
+				tracked_index = block.s.i;
+			}
+			render_fn(anchor, value, tracked_index);
+		} else {
+			render_fn(anchor, value);
+		}
+	});
+	return b;
 }
 
 /**
@@ -48,22 +48,22 @@ function create_item(anchor, value, index, render_fn, is_indexed) {
  * @returns {void}
  */
 function move(block, anchor) {
-  var node = block.s.start;
-  var end = block.s.end;
-
-  if (node === end) {
-    anchor.before(node);
-    return;
-  }
-  while (node !== null) {
-    var next_node = /** @type {Node} */ (next_sibling(node));
-    anchor.before(node);
-    node = next_node;
-    if (node === end) {
-      anchor.before(end);
-      break;
-    }
-  }
+	var node = block.s.start;
+	var end = block.s.end;
+
+	if (node === end) {
+		anchor.before(node);
+		return;
+	}
+	while (node !== null) {
+		var next_node = /** @type {Node} */ (next_sibling(node));
+		anchor.before(node);
+		node = next_node;
+		if (node === end) {
+			anchor.before(end);
+			break;
+		}
+	}
 }
 
 /**
@@ -72,15 +72,15 @@ function move(block, anchor) {
  * @returns {V[]}
  */
 function collection_to_array(collection) {
-  var array = is_array(collection) ? collection : collection == null ? [] : array_from(collection);
+	var array = is_array(collection) ? collection : collection == null ? [] : array_from(collection);
 
-  // If we are working with a tracked array, then we need to get a copy of
-  // the elements, as the array itself is proxied, and not useful in diffing
-  if (TRACKED_ARRAY in array) {
-    array = array_from(array);
-  }
+	// If we are working with a tracked array, then we need to get a copy of
+	// the elements, as the array itself is proxied, and not useful in diffing
+	if (TRACKED_ARRAY in array) {
+		array = array_from(array);
+	}
 
-  return array;
+	return array;
 }
 
 /**
@@ -92,23 +92,23 @@ function collection_to_array(collection) {
  * @returns {void}
  */
 export function for_block(node, get_collection, render_fn, flags) {
-  var is_controlled = (flags & IS_CONTROLLED) !== 0;
-  var is_indexed = (flags & IS_INDEXED) !== 0;
-  var anchor = /** @type {Element | Text} */ (node);
-
-  if (is_controlled) {
-    anchor = node.appendChild(create_text());
-  }
-
-  render(() => {
-    var block = /** @type {Block} */ (active_block);
-    var collection = get_collection();
-    var array = collection_to_array(collection);
-
-    untrack(() => {
-      reconcile(anchor, block, array, render_fn, is_controlled, is_indexed);
-    });
-  }, FOR_BLOCK);
+	var is_controlled = (flags & IS_CONTROLLED) !== 0;
+	var is_indexed = (flags & IS_INDEXED) !== 0;
+	var anchor = /** @type {Element | Text} */ (node);
+
+	if (is_controlled) {
+		anchor = node.appendChild(create_text());
+	}
+
+	render(() => {
+		var block = /** @type {Block} */ (active_block);
+		var collection = get_collection();
+		var array = collection_to_array(collection);
+
+		untrack(() => {
+			reconcile(anchor, block, array, render_fn, is_controlled, is_indexed);
+		});
+	}, FOR_BLOCK);
 }
 
 /**
@@ -119,13 +119,13 @@ export function for_block(node, get_collection, render_fn, flags) {
  * @returns {void}
  */
 function reconcile_fast_clear(anchor, block, array) {
-  var state = block.s;
-  var parent_node = /** @type {Element} */ (anchor.parentNode);
-  parent_node.textContent = '';
-  destroy_block_children(block);
-  parent_node.append(anchor);
-  state.array = array;
-  state.blocks = [];
+	var state = block.s;
+	var parent_node = /** @type {Element} */ (anchor.parentNode);
+	parent_node.textContent = '';
+	destroy_block_children(block);
+	parent_node.append(anchor);
+	state.array = array;
+	state.blocks = [];
 }
 
 /**
@@ -134,7 +134,7 @@ function reconcile_fast_clear(anchor, block, array) {
  * @returns {void}
  */
 function update_index(block, index) {
-  set(block.s.i, index, block);
+	set(block.s.i, index, block);
 }
 
 /**
@@ -148,248 +148,248 @@ function update_index(block, index) {
  * @returns {void}
  */
 function reconcile(anchor, block, b, render_fn, is_controlled, is_indexed) {
-  var state = block.s;
-
-  // Variables used in conditional branches - declare with initial values
-  /** @type {number} */
-  var a_start = 0;
-  /** @type {number} */
-  var b_start = 0;
-  /** @type {number} */
-  var a_left = 0;
-  /** @type {number} */
-  var b_left = 0;
-  /** @type {Int32Array} */
-  var sources = new Int32Array(0);
-  /** @type {boolean} */
-  var moved = false;
-  /** @type {number} */
-  var pos = 0;
-  /** @type {number} */
-  var patched = 0;
-  /** @type {number} */
-  var i = 0;
-
-  if (state === null) {
-    state = block.s = {
-      array: [],
-      blocks: [],
-    };
-  }
-
-  var a = state.array;
-  var a_length = a.length;
-  var b_length = b.length;
-  var j = 0;
-
-  // Fast-path for clear
-  if (is_controlled && b_length === 0) {
-    if (a_length > 0) {
-      reconcile_fast_clear(anchor, block, b);
-    }
-    return;
-  }
-  var b_blocks = Array(b_length);
-
-  // Fast-path for create
-  if (a_length === 0) {
-    for (; j < b_length; j++) {
-      b_blocks[j] = create_item(anchor, b[j], j, render_fn, is_indexed);
-    }
-    state.array = b;
-    state.blocks = b_blocks;
-    return;
-  }
-
-  var a_blocks = state.blocks;
-  var a_val = a[j];
-  var b_val = b[j];
-  var a_end = a_length - 1;
-  var b_end = b_length - 1;
-  var b_block;
-
-  outer: {
-    while (a_val === b_val) {
-      a[j] = b_val;
-      b_block = b_blocks[j] = a_blocks[j];
-      if (is_indexed) {
-        update_index(b_block, j);
-      }
-      ++j;
-      if (j > a_end || j > b_end) {
-        break outer;
-      }
-      a_val = a[j];
-      b_val = b[j];
-    }
-
-    a_val = a[a_end];
-    b_val = b[b_end];
-
-    while (a_val === b_val) {
-      a[a_end] = b_val;
-      b_block = b_blocks[b_end] = a_blocks[a_end];
-      if (is_indexed) {
-        update_index(b_block, b_end);
-      }
-      a_end--;
-      b_end--;
-      if (j > a_end || j > b_end) {
-        break outer;
-      }
-      a_val = a[a_end];
-      b_val = b[b_end];
-    }
-  }
-
-  var fast_path_removal = false;
-
-  if (j > a_end) {
-    if (j <= b_end) {
-      while (j <= b_end) {
-        b_val = b[j];
-        var target = j >= a_length ? anchor : a_blocks[j].s.start;
-        b_blocks[j] = create_item(target, b_val, j, render_fn, is_indexed);
-        j++;
-      }
-    }
-  } else if (j > b_end) {
-    while (j <= a_end) {
-      destroy_block(a_blocks[j++]);
-    }
-  } else {
-    a_start = j;
-    b_start = j;
-    a_left = a_end - j + 1;
-    b_left = b_end - j + 1;
-    sources = new Int32Array(b_left + 1);
-    moved = false;
-    pos = 0;
-    patched = 0;
-    i = 0;
-
-    fast_path_removal = is_controlled && a_left === a_length;
-
-    // When sizes are small, just loop them through
-    if (b_length < 4 || (a_left | b_left) < 32) {
-      for (i = a_start; i <= a_end; ++i) {
-        a_val = a[i];
-        if (patched < b_left) {
-          for (j = b_start; j <= b_end; j++) {
-            b_val = b[j];
-            if (a_val === b_val) {
-              sources[j - b_start] = i + 1;
-              if (fast_path_removal) {
-                fast_path_removal = false;
-                while (a_start < i) {
-                  destroy_block(a_blocks[a_start++]);
-                }
-              }
-              if (pos > j) {
-                moved = true;
-              } else {
-                pos = j;
-              }
-              b_block = b_blocks[j] = a_blocks[i];
-              if (is_indexed) {
-                update_index(b_block, j);
-              }
-              ++patched;
-              break;
-            }
-          }
-          if (!fast_path_removal && j > b_end) {
-            destroy_block(a_blocks[i]);
-          }
-        } else if (!fast_path_removal) {
-          destroy_block(a_blocks[i]);
-        }
-      }
-    } else {
-      var map = new Map();
-
-      for (i = b_start; i <= b_end; ++i) {
-        map.set(b[i], i);
-      }
-
-      for (i = a_start; i <= a_end; ++i) {
-        a_val = a[i];
-
-        if (patched < b_left) {
-          j = map.get(a_val);
-
-          if (j !== undefined) {
-            if (fast_path_removal) {
-              fast_path_removal = false;
-              // while (i > a_start) {
-              //     destroy_block(a[a_start++]);
-              // }
-            }
-            sources[j - b_start] = i + 1;
-            if (pos > j) {
-              moved = true;
-            } else {
-              pos = j;
-            }
-            b_val = b[j];
-            block = b_blocks[j] = a_blocks[i];
-            if (is_indexed) {
-              update_index(block, j);
-            }
-            ++patched;
-          } else if (!fast_path_removal) {
-            destroy_block(a_blocks[i]);
-          }
-        } else if (!fast_path_removal) {
-          destroy_block(a_blocks[i]);
-        }
-      }
-    }
-  }
-
-  if (fast_path_removal) {
-    reconcile_fast_clear(anchor, block, []);
-    reconcile(anchor, block, b, render_fn, is_controlled, is_indexed);
-    return;
-  } else if (moved) {
-    var next_pos = 0;
-    var seq = lis_algorithm(sources);
-    j = seq.length - 1;
-
-    for (i = b_left - 1; i >= 0; i--) {
-      if (sources[i] === 0) {
-        pos = i + b_start;
-        b_val = b[pos];
-        next_pos = pos + 1;
-
-        var target = next_pos < b_length ? b_blocks[next_pos].s.start : anchor;
-        b_blocks[pos] = create_item(target, b_val, pos, render_fn, is_indexed);
-      } else if (j < 0 || i !== seq[j]) {
-        pos = i + b_start;
-        b_val = b[pos];
-        next_pos = pos + 1;
-
-        var target = next_pos < b_length ? b_blocks[next_pos].s.start : anchor;
-        move(b_blocks[pos], target);
-      } else {
-        j--;
-      }
-    }
-  } else if (patched !== b_left) {
-    for (i = b_left - 1; i >= 0; i--) {
-      if (sources[i] === 0) {
-        pos = i + b_start;
-        b_val = b[pos];
-        next_pos = pos + 1;
-
-        var target = next_pos < b_length ? b_blocks[next_pos].s.start : anchor;
-        b_blocks[pos] = create_item(target, b_val, pos, render_fn, is_indexed);
-      }
-    }
-  }
-
-  state.array = b;
-  state.blocks = b_blocks;
+	var state = block.s;
+
+	// Variables used in conditional branches - declare with initial values
+	/** @type {number} */
+	var a_start = 0;
+	/** @type {number} */
+	var b_start = 0;
+	/** @type {number} */
+	var a_left = 0;
+	/** @type {number} */
+	var b_left = 0;
+	/** @type {Int32Array} */
+	var sources = new Int32Array(0);
+	/** @type {boolean} */
+	var moved = false;
+	/** @type {number} */
+	var pos = 0;
+	/** @type {number} */
+	var patched = 0;
+	/** @type {number} */
+	var i = 0;
+
+	if (state === null) {
+		state = block.s = {
+			array: [],
+			blocks: [],
+		};
+	}
+
+	var a = state.array;
+	var a_length = a.length;
+	var b_length = b.length;
+	var j = 0;
+
+	// Fast-path for clear
+	if (is_controlled && b_length === 0) {
+		if (a_length > 0) {
+			reconcile_fast_clear(anchor, block, b);
+		}
+		return;
+	}
+	var b_blocks = Array(b_length);
+
+	// Fast-path for create
+	if (a_length === 0) {
+		for (; j < b_length; j++) {
+			b_blocks[j] = create_item(anchor, b[j], j, render_fn, is_indexed);
+		}
+		state.array = b;
+		state.blocks = b_blocks;
+		return;
+	}
+
+	var a_blocks = state.blocks;
+	var a_val = a[j];
+	var b_val = b[j];
+	var a_end = a_length - 1;
+	var b_end = b_length - 1;
+	var b_block;
+
+	outer: {
+		while (a_val === b_val) {
+			a[j] = b_val;
+			b_block = b_blocks[j] = a_blocks[j];
+			if (is_indexed) {
+				update_index(b_block, j);
+			}
+			++j;
+			if (j > a_end || j > b_end) {
+				break outer;
+			}
+			a_val = a[j];
+			b_val = b[j];
+		}
+
+		a_val = a[a_end];
+		b_val = b[b_end];
+
+		while (a_val === b_val) {
+			a[a_end] = b_val;
+			b_block = b_blocks[b_end] = a_blocks[a_end];
+			if (is_indexed) {
+				update_index(b_block, b_end);
+			}
+			a_end--;
+			b_end--;
+			if (j > a_end || j > b_end) {
+				break outer;
+			}
+			a_val = a[a_end];
+			b_val = b[b_end];
+		}
+	}
+
+	var fast_path_removal = false;
+
+	if (j > a_end) {
+		if (j <= b_end) {
+			while (j <= b_end) {
+				b_val = b[j];
+				var target = j >= a_length ? anchor : a_blocks[j].s.start;
+				b_blocks[j] = create_item(target, b_val, j, render_fn, is_indexed);
+				j++;
+			}
+		}
+	} else if (j > b_end) {
+		while (j <= a_end) {
+			destroy_block(a_blocks[j++]);
+		}
+	} else {
+		a_start = j;
+		b_start = j;
+		a_left = a_end - j + 1;
+		b_left = b_end - j + 1;
+		sources = new Int32Array(b_left + 1);
+		moved = false;
+		pos = 0;
+		patched = 0;
+		i = 0;
+
+		fast_path_removal = is_controlled && a_left === a_length;
+
+		// When sizes are small, just loop them through
+		if (b_length < 4 || (a_left | b_left) < 32) {
+			for (i = a_start; i <= a_end; ++i) {
+				a_val = a[i];
+				if (patched < b_left) {
+					for (j = b_start; j <= b_end; j++) {
+						b_val = b[j];
+						if (a_val === b_val) {
+							sources[j - b_start] = i + 1;
+							if (fast_path_removal) {
+								fast_path_removal = false;
+								while (a_start < i) {
+									destroy_block(a_blocks[a_start++]);
+								}
+							}
+							if (pos > j) {
+								moved = true;
+							} else {
+								pos = j;
+							}
+							b_block = b_blocks[j] = a_blocks[i];
+							if (is_indexed) {
+								update_index(b_block, j);
+							}
+							++patched;
+							break;
+						}
+					}
+					if (!fast_path_removal && j > b_end) {
+						destroy_block(a_blocks[i]);
+					}
+				} else if (!fast_path_removal) {
+					destroy_block(a_blocks[i]);
+				}
+			}
+		} else {
+			var map = new Map();
+
+			for (i = b_start; i <= b_end; ++i) {
+				map.set(b[i], i);
+			}
+
+			for (i = a_start; i <= a_end; ++i) {
+				a_val = a[i];
+
+				if (patched < b_left) {
+					j = map.get(a_val);
+
+					if (j !== undefined) {
+						if (fast_path_removal) {
+							fast_path_removal = false;
+							// while (i > a_start) {
+							//     destroy_block(a[a_start++]);
+							// }
+						}
+						sources[j - b_start] = i + 1;
+						if (pos > j) {
+							moved = true;
+						} else {
+							pos = j;
+						}
+						b_val = b[j];
+						block = b_blocks[j] = a_blocks[i];
+						if (is_indexed) {
+							update_index(block, j);
+						}
+						++patched;
+					} else if (!fast_path_removal) {
+						destroy_block(a_blocks[i]);
+					}
+				} else if (!fast_path_removal) {
+					destroy_block(a_blocks[i]);
+				}
+			}
+		}
+	}
+
+	if (fast_path_removal) {
+		reconcile_fast_clear(anchor, block, []);
+		reconcile(anchor, block, b, render_fn, is_controlled, is_indexed);
+		return;
+	} else if (moved) {
+		var next_pos = 0;
+		var seq = lis_algorithm(sources);
+		j = seq.length - 1;
+
+		for (i = b_left - 1; i >= 0; i--) {
+			if (sources[i] === 0) {
+				pos = i + b_start;
+				b_val = b[pos];
+				next_pos = pos + 1;
+
+				var target = next_pos < b_length ? b_blocks[next_pos].s.start : anchor;
+				b_blocks[pos] = create_item(target, b_val, pos, render_fn, is_indexed);
+			} else if (j < 0 || i !== seq[j]) {
+				pos = i + b_start;
+				b_val = b[pos];
+				next_pos = pos + 1;
+
+				var target = next_pos < b_length ? b_blocks[next_pos].s.start : anchor;
+				move(b_blocks[pos], target);
+			} else {
+				j--;
+			}
+		}
+	} else if (patched !== b_left) {
+		for (i = b_left - 1; i >= 0; i--) {
+			if (sources[i] === 0) {
+				pos = i + b_start;
+				b_val = b[pos];
+				next_pos = pos + 1;
+
+				var target = next_pos < b_length ? b_blocks[next_pos].s.start : anchor;
+				b_blocks[pos] = create_item(target, b_val, pos, render_fn, is_indexed);
+			}
+		}
+	}
+
+	state.array = b;
+	state.blocks = b_blocks;
 }
 
 /** @type {Int32Array} */
@@ -403,64 +403,64 @@ let maxLen = 0;
  * @returns {Int32Array}
  */
 function lis_algorithm(arr) {
-  let arrI = 0;
-  let i = 0;
-  let j = 0;
-  let k = 0;
-  let u = 0;
-  let v = 0;
-  let c = 0;
-  var len = arr.length;
-
-  if (len > maxLen) {
-    maxLen = len;
-    result = new Int32Array(len);
-    p = new Int32Array(len);
-  }
-
-  for (; i < len; ++i) {
-    arrI = arr[i];
-
-    if (arrI !== 0) {
-      j = result[k];
-      if (arr[j] < arrI) {
-        p[i] = j;
-        result[++k] = i;
-        continue;
-      }
-
-      u = 0;
-      v = k;
-
-      while (u < v) {
-        c = (u + v) >> 1;
-        if (arr[result[c]] < arrI) {
-          u = c + 1;
-        } else {
-          v = c;
-        }
-      }
-
-      if (arrI < arr[result[u]]) {
-        if (u > 0) {
-          p[i] = result[u - 1];
-        }
-        result[u] = i;
-      }
-    }
-  }
-
-  u = k + 1;
-  var seq = new Int32Array(u);
-  v = result[u - 1];
-
-  while (u-- > 0) {
-    seq[u] = v;
-    v = p[v];
-    result[u] = 0;
-  }
-
-  return seq;
+	let arrI = 0;
+	let i = 0;
+	let j = 0;
+	let k = 0;
+	let u = 0;
+	let v = 0;
+	let c = 0;
+	var len = arr.length;
+
+	if (len > maxLen) {
+		maxLen = len;
+		result = new Int32Array(len);
+		p = new Int32Array(len);
+	}
+
+	for (; i < len; ++i) {
+		arrI = arr[i];
+
+		if (arrI !== 0) {
+			j = result[k];
+			if (arr[j] < arrI) {
+				p[i] = j;
+				result[++k] = i;
+				continue;
+			}
+
+			u = 0;
+			v = k;
+
+			while (u < v) {
+				c = (u + v) >> 1;
+				if (arr[result[c]] < arrI) {
+					u = c + 1;
+				} else {
+					v = c;
+				}
+			}
+
+			if (arrI < arr[result[u]]) {
+				if (u > 0) {
+					p[i] = result[u - 1];
+				}
+				result[u] = i;
+			}
+		}
+	}
+
+	u = k + 1;
+	var seq = new Int32Array(u);
+	v = result[u - 1];
+
+	while (u-- > 0) {
+		seq[u] = v;
+		v = p[v];
+		result[u] = 0;
+	}
+
+	return seq;
 }
 
 /**
@@ -471,46 +471,46 @@ function lis_algorithm(arr) {
  * @returns {V[]}
  */
 export function keyed(collection, key_fn) {
-  var block = active_block;
-  if (block === null || (block.f & FOR_BLOCK) === 0) {
-    throw new Error('keyed() must be used inside a for block');
-  }
+	var block = active_block;
+	if (block === null || (block.f & FOR_BLOCK) === 0) {
+		throw new Error('keyed() must be used inside a for block');
+	}
 
-  var b_array = collection_to_array(collection);
-  var b_keys = b_array.map(key_fn);
+	var b_array = collection_to_array(collection);
+	var b_keys = b_array.map(key_fn);
 
-  // We only need to do this in DEV
-  var b = new Set(b_keys);
-  if (b.size !== b_keys.length) {
-    throw new Error('Duplicate keys are not allowed');
-  }
+	// We only need to do this in DEV
+	var b = new Set(b_keys);
+	if (b.size !== b_keys.length) {
+		throw new Error('Duplicate keys are not allowed');
+	}
 
-  var state = block.s;
+	var state = block.s;
 
-  if (state === null) {
-    return b_array;
-  }
+	if (state === null) {
+		return b_array;
+	}
 
-  var a_array = state.array;
-  var a_keys = a_array.map(key_fn);
-  var a = new Map();
+	var a_array = state.array;
+	var a_keys = a_array.map(key_fn);
+	var a = new Map();
 
-  for (let i = 0; i < a_keys.length; i++) {
-    a.set(a_keys[i], i);
-  }
+	for (let i = 0; i < a_keys.length; i++) {
+		a.set(a_keys[i], i);
+	}
 
-  if (a.size !== a_keys.length) {
-    throw new Error('Duplicate keys are not allowed');
-  }
+	if (a.size !== a_keys.length) {
+		throw new Error('Duplicate keys are not allowed');
+	}
 
-  for (let i = 0; i < b_keys.length; i++) {
-    var b_val = b_keys[i];
-    var index = a.get(b_val);
+	for (let i = 0; i < b_keys.length; i++) {
+		var b_val = b_keys[i];
+		var index = a.get(b_val);
 
-    if (index !== undefined) {
-      b_array[i] = a_array[index];
-    }
-  }
+		if (index !== undefined) {
+			b_array[i] = a_array[index];
+		}
+	}
 
-  return b_array;
+	return b_array;
 }

package/src/runtime/internal/client/if.js

@@ -9,38 +9,38 @@ import { IF_BLOCK, UNINITIALIZED } from './constants.js';
  * @returns {void}
  */
 export function if_block(node, fn) {
-  var anchor = node;
-  var has_branch = false;
-  /** @type {any} */
-  var condition = UNINITIALIZED;
-  /** @type {Block | null} */
-  var b = null;
+	var anchor = node;
+	var has_branch = false;
+	/** @type {any} */
+	var condition = UNINITIALIZED;
+	/** @type {Block | null} */
+	var b = null;
 
-  /** @type {(fn: (anchor: Node) => void, flag?: boolean) => void} */
-  var set_branch = (fn, flag = true) => {
-    has_branch = true;
-    update_branch(flag, fn);
-  };
+	/** @type {(fn: (anchor: Node) => void, flag?: boolean) => void} */
+	var set_branch = (fn, flag = true) => {
+		has_branch = true;
+		update_branch(flag, fn);
+	};
 
-  /** @type {(new_condition: any, fn: ((anchor: Node) => void) | null) => void} */
-  var update_branch = (new_condition, fn) => {
-    if (condition === (condition = new_condition)) return;
+	/** @type {(new_condition: any, fn: ((anchor: Node) => void) | null) => void} */
+	var update_branch = (new_condition, fn) => {
+		if (condition === (condition = new_condition)) return;
 
-    if (b !== null) {
-      destroy_block(b);
-      b = null;
-    }
+		if (b !== null) {
+			destroy_block(b);
+			b = null;
+		}
 
-    if (fn !== null) {
-      b = branch(() => fn(anchor));
-    }
-  };
+		if (fn !== null) {
+			b = branch(() => fn(anchor));
+		}
+	};
 
-  render(() => {
-    has_branch = false;
-    fn(set_branch);
-    if (!has_branch) {
-      update_branch(null, null);
-    }
-  }, IF_BLOCK);
+	render(() => {
+		has_branch = false;
+		fn(set_branch);
+		if (!has_branch) {
+			update_branch(null, null);
+		}
+	}, IF_BLOCK);
 }

package/src/runtime/internal/client/index.js

@@ -61,3 +61,5 @@ export { template, append } from './template.js';
 export { tracked_array } from '../../array.js';
 
 export { head } from './head.js';
+
+export { script } from './script.js';

package/src/runtime/internal/client/script.js

@@ -0,0 +1,16 @@
+import { effect } from './blocks';
+/**
+ * @param {Text | Comment} node
+ * @param {string} content
+ */
+export function script(node, content) {
+	effect(() => {
+		var script = document.createElement('script');
+		script.textContent = content;
+		node.before(script);
+
+		return () => {
+			script.remove();
+		};
+	});
+}

package/tests/client/__snapshots__/basic.test.ripple.snap

@@ -37,6 +37,19 @@ exports[`basic client > handles boolean attributes with no prop value provides 1
 </div>
 `;
 
+exports[`basic client > handles boolean props correctly 1`] = `
+<div>
+  <div
+    data-disabled=""
+  />
+  <input
+    disabled=""
+  />
+  <!---->
+  
+</div>
+`;
+
 exports[`basic client > render semi-dynamic text 1`] = `
 <div>
   <div>

package/tests/client/basic.test.ripple

@@ -1547,5 +1547,20 @@ describe('basic client', () => {
 		expect(pre1.textContent).toBe('4');
 		expect(pre2.textContent).toBe('2');
 	});
+
+	it('handles boolean props correctly', () => {
+		component App() {
+			<div data-disabled />
+
+			<Child isDisabled />
+		}
+
+		component Child({ isDisabled }) {
+			<input disabled={isDisabled} />
+		}
+
+		render(App);
+		expect(container).toMatchSnapshot();
+	});
 });