mustardscript 0.1.0 → 0.1.2

package/crates/mustard/src/runtime/builtins/support.rs

@@ -1,561 +0,0 @@
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use super::*;
-
-const MAX_TIME_MS: f64 = 8_640_000_000_000_000.0;
-const MS_PER_SECOND: i64 = 1_000;
-const MS_PER_MINUTE: i64 = 60 * MS_PER_SECOND;
-const MS_PER_HOUR: i64 = 60 * MS_PER_MINUTE;
-const MS_PER_DAY: i64 = 24 * MS_PER_HOUR;
-
-#[derive(Debug, Clone, Copy)]
-pub(super) struct RegExpFlagsState {
-    pub(super) global: bool,
-    pub(super) ignore_case: bool,
-    pub(super) multiline: bool,
-    pub(super) dot_all: bool,
-    pub(super) unicode: bool,
-    pub(super) sticky: bool,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct RegExpMatchData {
-    pub(crate) start_byte: usize,
-    pub(crate) end_byte: usize,
-    pub(crate) start_index: usize,
-    pub(crate) end_index: usize,
-    pub(crate) captures: Vec<Option<String>>,
-    pub(crate) named_groups: IndexMap<String, Option<String>>,
-}
-
-#[derive(Debug, Clone)]
-pub(super) enum StringSearchPattern {
-    Literal(String),
-    RegExp {
-        object: ObjectKey,
-        regex: RegExpObject,
-    },
-}
-
-#[derive(Debug, Clone, Copy)]
-pub(super) struct DateTimeFields {
-    pub(super) year: i64,
-    pub(super) month: u8,
-    pub(super) day: u8,
-    pub(super) hour: u8,
-    pub(super) minute: u8,
-    pub(super) second: u8,
-    pub(super) millisecond: u16,
-}
-
-pub(super) fn current_time_millis() -> f64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|duration| duration.as_millis() as f64)
-        .unwrap_or(0.0)
-}
-
-pub(super) fn parse_date_timestamp_ms(value: &str) -> f64 {
-    parse_iso_date_timestamp_ms(value).unwrap_or(f64::NAN)
-}
-
-pub(super) fn time_clip(timestamp_ms: f64) -> f64 {
-    if !timestamp_ms.is_finite() || timestamp_ms.abs() > MAX_TIME_MS {
-        f64::NAN
-    } else {
-        let clipped = timestamp_ms.trunc();
-        if clipped == 0.0 { 0.0 } else { clipped }
-    }
-}
-
-fn parse_iso_date_timestamp_ms(value: &str) -> Option<f64> {
-    let (year, mut index) = parse_iso_year(value)?;
-    index += 1;
-    let month = parse_two_digits(value, &mut index)?;
-    require_byte(value, &mut index, b'-')?;
-    let day = parse_two_digits(value, &mut index)?;
-    if !is_valid_date(year, month, day) {
-        return None;
-    }
-
-    let days = days_from_civil(year, month, day);
-    if index == value.len() {
-        return Some(days as f64 * MS_PER_DAY as f64);
-    }
-
-    require_byte(value, &mut index, b'T')?;
-    let hour = parse_two_digits(value, &mut index)?;
-    require_byte(value, &mut index, b':')?;
-    let minute = parse_two_digits(value, &mut index)?;
-    require_byte(value, &mut index, b':')?;
-    let second = parse_two_digits(value, &mut index)?;
-    if hour > 23 || minute > 59 || second > 59 {
-        return None;
-    }
-
-    let mut millisecond = 0i64;
-    if matches!(value.as_bytes().get(index), Some(b'.')) {
-        index += 1;
-        let start = index;
-        while value.as_bytes().get(index).is_some_and(u8::is_ascii_digit) {
-            index += 1;
-        }
-        if index == start {
-            return None;
-        }
-        let digits = &value.as_bytes()[start..index];
-        let mut parsed = 0i64;
-        for digit in digits.iter().take(3) {
-            parsed = parsed * 10 + i64::from(digit - b'0');
-        }
-        for _ in digits.len().min(3)..3 {
-            parsed *= 10;
-        }
-        millisecond = parsed;
-    }
-
-    let offset_ms = match value.as_bytes().get(index).copied() {
-        Some(b'Z') if index + 1 == value.len() => 0i64,
-        Some(sign @ (b'+' | b'-')) => {
-            index += 1;
-            let offset_hours = parse_two_digits(value, &mut index)?;
-            require_byte(value, &mut index, b':')?;
-            let offset_minutes = parse_two_digits(value, &mut index)?;
-            if offset_hours > 23 || offset_minutes > 59 || index != value.len() {
-                return None;
-            }
-            let magnitude =
-                i64::from(offset_hours) * MS_PER_HOUR + i64::from(offset_minutes) * MS_PER_MINUTE;
-            if sign == b'+' { magnitude } else { -magnitude }
-        }
-        _ => return None,
-    };
-
-    let time_ms = i64::from(hour) * MS_PER_HOUR
-        + i64::from(minute) * MS_PER_MINUTE
-        + i64::from(second) * MS_PER_SECOND
-        + millisecond;
-    let timestamp_ms =
-        i128::from(days) * i128::from(MS_PER_DAY) + i128::from(time_ms) - i128::from(offset_ms);
-    if !(i128::from(i64::MIN)..=i128::from(i64::MAX)).contains(&timestamp_ms) {
-        return None;
-    }
-    Some(timestamp_ms as f64)
-}
-
-pub(super) fn date_time_fields_from_timestamp_ms(timestamp_ms: f64) -> Option<DateTimeFields> {
-    if !timestamp_ms.is_finite() {
-        return None;
-    }
-    let timestamp_ms = if timestamp_ms.trunc() == 0.0 {
-        0.0
-    } else {
-        timestamp_ms.trunc()
-    };
-    if timestamp_ms < i64::MIN as f64 || timestamp_ms > i64::MAX as f64 {
-        return None;
-    }
-    let timestamp_ms = timestamp_ms as i64;
-    let days = timestamp_ms.div_euclid(MS_PER_DAY);
-    let day_ms = timestamp_ms.rem_euclid(MS_PER_DAY);
-    let (year, month, day) = civil_from_days(days);
-    Some(DateTimeFields {
-        year,
-        month,
-        day,
-        hour: (day_ms / MS_PER_HOUR) as u8,
-        minute: ((day_ms % MS_PER_HOUR) / MS_PER_MINUTE) as u8,
-        second: ((day_ms % MS_PER_MINUTE) / MS_PER_SECOND) as u8,
-        millisecond: (day_ms % MS_PER_SECOND) as u16,
-    })
-}
-
-pub(super) fn format_iso_datetime(timestamp_ms: f64) -> Option<String> {
-    let datetime = date_time_fields_from_timestamp_ms(timestamp_ms)?;
-    Some(format!(
-        "{}-{:02}-{:02}T{:02}:{:02}:{:02}.{:03}Z",
-        format_iso_year(datetime.year),
-        datetime.month,
-        datetime.day,
-        datetime.hour,
-        datetime.minute,
-        datetime.second,
-        datetime.millisecond,
-    ))
-}
-
-fn parse_iso_year(value: &str) -> Option<(i64, usize)> {
-    let bytes = value.as_bytes();
-    let mut index = 0usize;
-    let signed = matches!(bytes.first(), Some(b'+' | b'-'));
-    if signed {
-        index += 1;
-    }
-    while bytes.get(index).is_some_and(u8::is_ascii_digit) {
-        index += 1;
-    }
-    let digits = if signed {
-        index.saturating_sub(1)
-    } else {
-        index
-    };
-    if digits == 0 || bytes.get(index) != Some(&b'-') {
-        return None;
-    }
-    if (!signed && digits != 4) || (signed && digits != 6) {
-        return None;
-    }
-    Some((value[..index].parse::<i64>().ok()?, index))
-}
-
-fn parse_two_digits(value: &str, index: &mut usize) -> Option<u8> {
-    let bytes = value.as_bytes();
-    let tens = *bytes.get(*index)?;
-    let ones = *bytes.get(*index + 1)?;
-    if !tens.is_ascii_digit() || !ones.is_ascii_digit() {
-        return None;
-    }
-    *index += 2;
-    Some((tens - b'0') * 10 + (ones - b'0'))
-}
-
-fn require_byte(value: &str, index: &mut usize, expected: u8) -> Option<()> {
-    if value.as_bytes().get(*index) == Some(&expected) {
-        *index += 1;
-        Some(())
-    } else {
-        None
-    }
-}
-
-fn is_valid_date(year: i64, month: u8, day: u8) -> bool {
-    matches!(month, 1..=12) && (1..=days_in_month(year, month)).contains(&day)
-}
-
-fn is_leap_year(year: i64) -> bool {
-    (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
-}
-
-fn days_in_month(year: i64, month: u8) -> u8 {
-    match month {
-        1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
-        4 | 6 | 9 | 11 => 30,
-        2 if is_leap_year(year) => 29,
-        2 => 28,
-        _ => 0,
-    }
-}
-
-fn days_from_civil(year: i64, month: u8, day: u8) -> i64 {
-    let year = year - i64::from(month <= 2);
-    let era = if year >= 0 { year } else { year - 399 } / 400;
-    let year_of_era = year - era * 400;
-    let shifted_month = i64::from(month) + if month > 2 { -3 } else { 9 };
-    let day_of_year = (153 * shifted_month + 2) / 5 + i64::from(day) - 1;
-    let day_of_era = year_of_era * 365 + year_of_era / 4 - year_of_era / 100 + day_of_year;
-    era * 146_097 + day_of_era - 719_468
-}
-
-fn civil_from_days(days: i64) -> (i64, u8, u8) {
-    let shifted = days + 719_468;
-    let era = if shifted >= 0 {
-        shifted
-    } else {
-        shifted - 146_096
-    } / 146_097;
-    let day_of_era = shifted - era * 146_097;
-    let year_of_era =
-        (day_of_era - day_of_era / 1_460 + day_of_era / 36_524 - day_of_era / 146_096) / 365;
-    let year = year_of_era + era * 400;
-    let day_of_year = day_of_era - (365 * year_of_era + year_of_era / 4 - year_of_era / 100);
-    let month_prime = (5 * day_of_year + 2) / 153;
-    let day = day_of_year - (153 * month_prime + 2) / 5 + 1;
-    let month = month_prime + if month_prime < 10 { 3 } else { -9 };
-    (year + i64::from(month <= 2), month as u8, day as u8)
-}
-
-fn format_iso_year(year: i64) -> String {
-    if (0..=9_999).contains(&year) {
-        format!("{year:04}")
-    } else if year < 0 {
-        format!("-{:06}", year.unsigned_abs())
-    } else {
-        format!("+{:06}", year as u64)
-    }
-}
-
-pub(super) fn format_en_us_number_grouped(integer: &str) -> String {
-    let mut chars = integer.chars().collect::<Vec<_>>();
-    let negative = matches!(chars.first(), Some('-'));
-    if negative {
-        chars.remove(0);
-    }
-    let mut grouped = String::new();
-    for (index, ch) in chars.iter().rev().enumerate() {
-        if index > 0 && index % 3 == 0 {
-            grouped.push(',');
-        }
-        grouped.push(*ch);
-    }
-    let grouped = grouped.chars().rev().collect::<String>();
-    if negative {
-        format!("-{grouped}")
-    } else {
-        grouped
-    }
-}
-
-pub(super) fn clamp_index(index: i64, len: usize) -> usize {
-    if index < 0 {
-        0
-    } else {
-        (index as usize).min(len)
-    }
-}
-
-pub(super) fn normalize_relative_bound(index: i64, len: usize) -> usize {
-    let len = len as i64;
-    if index < 0 {
-        (len + index).max(0) as usize
-    } else {
-        index.min(len) as usize
-    }
-}
-
-pub(super) fn normalize_search_index(index: i64, len: usize) -> usize {
-    if index < 0 {
-        normalize_relative_bound(index, len)
-    } else {
-        clamp_index(index, len)
-    }
-}
-
-pub(super) fn collect_literal_matches(value: &str, needle: &str) -> Vec<RegExpMatchData> {
-    if needle.is_empty() {
-        let total = value.chars().count();
-        return (0..=total)
-            .map(|index| {
-                let byte = char_index_to_byte_index(value, index);
-                RegExpMatchData {
-                    start_byte: byte,
-                    end_byte: byte,
-                    start_index: index,
-                    end_index: index,
-                    captures: Vec::new(),
-                    named_groups: IndexMap::new(),
-                }
-            })
-            .collect();
-    }
-
-    let mut matches = Vec::new();
-    let mut start_index = 0usize;
-    while let Some(matched) = find_string_pattern(value, needle, start_index).map(|index| {
-        let start_byte = char_index_to_byte_index(value, index);
-        let end_index = index + needle.chars().count();
-        let end_byte = char_index_to_byte_index(value, end_index);
-        RegExpMatchData {
-            start_byte,
-            end_byte,
-            start_index: index,
-            end_index,
-            captures: Vec::new(),
-            named_groups: IndexMap::new(),
-        }
-    }) {
-        start_index = matched.end_index;
-        matches.push(matched);
-    }
-    matches
-}
-
-pub(super) fn char_index_to_byte_index(value: &str, index: usize) -> usize {
-    if index == 0 {
-        return 0;
-    }
-    value
-        .char_indices()
-        .nth(index)
-        .map(|(byte, _)| byte)
-        .unwrap_or_else(|| value.len())
-}
-
-pub(super) fn byte_index_to_char_index(value: &str, byte_index: usize) -> usize {
-    value[..byte_index].chars().count()
-}
-
-pub(super) fn advance_char_index(value: &str, index: usize) -> usize {
-    let total = value.chars().count();
-    (index + 1).min(total)
-}
-
-pub(super) fn find_string_pattern(value: &str, needle: &str, start: usize) -> Option<usize> {
-    let start_byte = char_index_to_byte_index(value, start);
-    value[start_byte..]
-        .find(needle)
-        .map(|byte_index| byte_index_to_char_index(value, start_byte + byte_index))
-}
-
-pub(super) fn split_string_by_pattern(
-    value: &str,
-    separator: Option<&str>,
-    limit: usize,
-) -> Vec<String> {
-    let mut parts = Vec::new();
-    match separator {
-        None => {
-            parts.push(value.to_string());
-        }
-        Some("") => {
-            if limit == 0 {
-                return Vec::new();
-            }
-            if value.is_empty() {
-                return parts;
-            }
-            for ch in value.chars() {
-                if parts.len() == limit {
-                    break;
-                }
-                parts.push(ch.to_string());
-            }
-            return parts;
-        }
-        Some(separator) => {
-            let mut remaining = value;
-            while let Some(index) = remaining.find(separator) {
-                if parts.len() + 1 == limit {
-                    parts.push(remaining[..index].to_string());
-                    return parts;
-                }
-                parts.push(remaining[..index].to_string());
-                remaining = &remaining[index + separator.len()..];
-            }
-            if parts.len() < limit {
-                parts.push(remaining.to_string());
-            }
-        }
-    }
-    parts
-}
-
-pub(super) fn replace_all_string_matches(value: &str, search: &str, replacement: &str) -> String {
-    if search.is_empty() {
-        let mut result = String::new();
-        for ch in value.chars() {
-            result.push_str(replacement);
-            result.push(ch);
-        }
-        result.push_str(replacement);
-        return result;
-    }
-
-    let mut result = String::new();
-    let mut start_index = 0usize;
-    while let Some(index) = find_string_pattern(value, search, start_index) {
-        let start_byte = char_index_to_byte_index(value, index);
-        let end_index = index + search.chars().count();
-        let end_byte = char_index_to_byte_index(value, end_index);
-        result.push_str(&value[char_index_to_byte_index(value, start_index)..start_byte]);
-        result.push_str(replacement);
-        start_index = end_index;
-        if start_byte == end_byte {
-            start_index = advance_char_index(value, start_index);
-        }
-    }
-    result.push_str(&value[char_index_to_byte_index(value, start_index)..]);
-    result
-}
-
-pub(super) fn replace_first_string_match(value: &str, search: &str, replacement: &str) -> String {
-    if search.is_empty() {
-        let mut result = String::new();
-        result.push_str(replacement);
-        result.push_str(value);
-        return result;
-    }
-    let Some(index) = find_string_pattern(value, search, 0) else {
-        return value.to_string();
-    };
-    let start_byte = char_index_to_byte_index(value, index);
-    let end_index = index + search.chars().count();
-    let end_byte = char_index_to_byte_index(value, end_index);
-    let mut result = String::new();
-    result.push_str(&value[..start_byte]);
-    result.push_str(replacement);
-    result.push_str(&value[end_byte..]);
-    result
-}
-
-pub(super) fn expand_regexp_replacement_template(
-    replacement: &str,
-    input: &str,
-    matched: &RegExpMatchData,
-) -> String {
-    let mut result = String::new();
-    let mut chars = replacement.chars().peekable();
-    while let Some(ch) = chars.next() {
-        if ch != '$' {
-            result.push(ch);
-            continue;
-        }
-        match chars.peek().copied() {
-            Some('$') => {
-                chars.next();
-                result.push('$');
-            }
-            Some('&') => {
-                chars.next();
-                result.push_str(&input[matched.start_byte..matched.end_byte]);
-            }
-            Some('`') => {
-                chars.next();
-                result.push_str(&input[..matched.start_byte]);
-            }
-            Some('\'') => {
-                chars.next();
-                result.push_str(&input[matched.end_byte..]);
-            }
-            Some('<') => {
-                chars.next();
-                let mut name = String::new();
-                let mut closed = false;
-                for next in chars.by_ref() {
-                    if next == '>' {
-                        closed = true;
-                        break;
-                    }
-                    name.push(next);
-                }
-                if closed {
-                    if let Some(Some(value)) = matched.named_groups.get(&name) {
-                        result.push_str(value);
-                    }
-                } else {
-                    result.push('$');
-                    result.push('<');
-                    result.push_str(&name);
-                    break;
-                }
-            }
-            Some(digit @ '1'..='9') => {
-                let mut index = digit.to_digit(10).unwrap() as usize;
-                chars.next();
-                if let Some(next_digit @ '0'..='9') = chars.peek().copied() {
-                    let candidate = index * 10 + next_digit.to_digit(10).unwrap() as usize;
-                    if candidate <= matched.captures.len() {
-                        index = candidate;
-                        chars.next();
-                    }
-                }
-                if index > 0
-                    && let Some(Some(value)) = matched.captures.get(index - 1)
-                {
-                    result.push_str(value);
-                }
-            }
-            _ => result.push('$'),
-        }
-    }
-    result
-}

package/crates/mustard/src/runtime/bytecode.rs

@@ -1,123 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    ir::{BinaryOp, Pattern, PropertyName, UnaryOp, UpdateOp},
-    span::SourceSpan,
-};
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BytecodeProgram {
-    pub functions: Vec<FunctionPrototype>,
-    pub root: usize,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct FunctionPrototype {
-    pub name: Option<String>,
-    pub length: usize,
-    pub display_source: String,
-    pub params: Vec<Pattern>,
-    pub rest: Option<Pattern>,
-    pub code: Vec<Instruction>,
-    pub is_async: bool,
-    pub is_arrow: bool,
-    pub span: SourceSpan,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum Instruction {
-    PushUndefined,
-    PushNull,
-    PushBool(bool),
-    PushNumber(f64),
-    PushString(String),
-    PushRegExp {
-        pattern: String,
-        flags: String,
-    },
-    LoadName(String),
-    LoadGlobalObject,
-    StoreName(String),
-    InitializePattern(Pattern),
-    PushEnv,
-    PopEnv,
-    DeclareName {
-        name: String,
-        mutable: bool,
-    },
-    MakeClosure {
-        function_id: usize,
-    },
-    MakeArray {
-        count: usize,
-    },
-    ArrayPush,
-    ArrayPushHole,
-    ArrayExtend,
-    MakeObject {
-        keys: Vec<PropertyName>,
-    },
-    CopyDataProperties,
-    CreateIterator,
-    IteratorNext,
-    GetPropStatic {
-        name: String,
-        optional: bool,
-    },
-    GetPropComputed {
-        optional: bool,
-    },
-    SetPropStatic {
-        name: String,
-    },
-    SetPropComputed,
-    Unary(UnaryOp),
-    Binary(BinaryOp),
-    Update(UpdateOp),
-    PatternArrayIndex(usize),
-    PatternArrayRest(usize),
-    PatternObjectRest(Vec<String>),
-    Pop,
-    Dup,
-    Dup2,
-    PushHandler {
-        catch: Option<usize>,
-        finally: Option<usize>,
-    },
-    PopHandler,
-    EnterFinally {
-        exit: usize,
-    },
-    BeginCatch,
-    Throw {
-        span: SourceSpan,
-    },
-    PushPendingJump {
-        target: usize,
-        target_handler_depth: usize,
-        target_scope_depth: usize,
-    },
-    PushPendingReturn,
-    PushPendingThrow,
-    ContinuePending,
-    Jump(usize),
-    JumpIfFalse(usize),
-    JumpIfTrue(usize),
-    JumpIfNullish(usize),
-    Call {
-        argc: usize,
-        with_this: bool,
-        optional: bool,
-    },
-    CallWithArray {
-        with_this: bool,
-        optional: bool,
-    },
-    Await,
-    Construct {
-        argc: usize,
-    },
-    ConstructWithArray,
-    Return,
-    PushBigInt(String),
-}