mini_racer_rs 1.0.0

data/ext/mini_racer_rs/src/encode.rs

@@ -0,0 +1,333 @@
+use std::collections::HashMap;
+
+use magnus::encoding::{EncodingCapable, RbEncoding};
+use magnus::r_hash::ForEach;
+use magnus::typed_data::Obj;
+use magnus::value::ReprValue;
+use magnus::{
+    Error, Fixnum, Float, Module, Object, RArray, RClass, RHash, RModule, RObject, RString, Ruby,
+    Time, Value,
+};
+use mini_racer_wire::Writer;
+
+use crate::gc_root::{OnceRoot, Pins, StaticRoot};
+use crate::rb_raw::{self, RubyType};
+
+const BIGINT_MAX_WORDS: usize = (16 << 20) / 8;
+// mini_racer formats these messages into a 64-byte buffer.
+const MESSAGE_MAX_BYTES: usize = 63;
+
+/// Resolved by `Context#initialize` while unresolved, as `mini_racer` resolves
+/// it at each `Context.new`, since `date` may be required after this gem.
+pub static DATE_TIME: OnceRoot<Value> = OnceRoot::new();
+
+#[expect(
+    clippy::expect_used,
+    reason = "the vocabulary defines the class, and a root initializer cannot return an error"
+)]
+static BINARY: StaticRoot<RClass> = StaticRoot::new(|ruby| {
+    ruby.class_object()
+        .const_get::<_, RModule>("MiniRacer")
+        .and_then(|racer| racer.const_get("Binary"))
+        .expect("the vocabulary defines MiniRacer::Binary")
+});
+
+enum EncodeError {
+    // mini_racer's text for a value it cannot send, cut as it cuts it.
+    Unsupported(Vec<u8>),
+    Raised(Error),
+}
+
+impl EncodeError {
+    fn unsupported(message: &str) -> Self {
+        let bytes = message.as_bytes();
+        Self::Unsupported(bytes.get(..MESSAGE_MAX_BYTES).unwrap_or(bytes).to_vec())
+    }
+}
+
+impl From<Error> for EncodeError {
+    fn from(error: Error) -> Self {
+        Self::Raised(error)
+    }
+}
+
+enum Item {
+    // A pinned value, by its index in the holder.
+    Value(usize),
+    // An element read when its turn comes, as serialize1 reads them, so a
+    // to_time that changes the array is seen.
+    Element { array: usize, index: isize },
+    EndArray(u32),
+    EndObject(u32),
+}
+
+// Iterative so a deeply nested argument cannot overflow the Ruby thread's
+// stack; how deep V8 then reads is V8's own limit.
+struct Encoder<'r, 'o> {
+    ruby: &'r Ruby,
+    // The object, not a reference into its data: each use of the object keeps
+    // it where the GC finds it, while a bare data pointer lets an optimized
+    // build drop it and the GC free it mid-encode.
+    pins: Obj<Pins>,
+    writer: Writer<'o>,
+    work: Vec<Item>,
+    seen: HashMap<u64, u32>,
+}
+
+/// Writes `value` as `mini_racer`'s `serialize` does, with the object ids V8
+/// assigns on reading. Each caller raises `mini_racer`'s text for a value it
+/// cannot send in its own way, through `unsupported`.
+pub fn encode(
+    ruby: &Ruby,
+    value: Value,
+    unsupported: impl FnOnce(Vec<u8>) -> Error,
+) -> Result<Vec<u8>, Error> {
+    let mut out = Vec::new();
+    let mut encoder = Encoder {
+        ruby,
+        pins: Pins::new(ruby),
+        writer: Writer::new(&mut out),
+        work: Vec::new(),
+        seen: HashMap::new(),
+    };
+    let root = encoder.pins.push(value);
+    encoder.work.push(Item::Value(root));
+    encoder.run().map_err(|error| match error {
+        EncodeError::Unsupported(message) => unsupported(message),
+        EncodeError::Raised(error) => error,
+    })?;
+    Ok(out)
+}
+
+fn length(len: usize) -> u32 {
+    u32::try_from(len).unwrap_or(u32::MAX)
+}
+
+impl Encoder<'_, '_> {
+    fn pinned(&self, index: usize) -> Value {
+        self.pins
+            .get(self.ruby, index)
+            .unwrap_or_else(|| self.ruby.qnil().as_value())
+    }
+
+    fn run(&mut self) -> Result<(), EncodeError> {
+        while let Some(item) = self.work.pop() {
+            match item {
+                Item::EndArray(length) => self.writer.end_array(length),
+                Item::EndObject(count) => self.writer.end_object(count),
+                Item::Value(index) => self.value(self.pinned(index))?,
+                Item::Element { array, index } => {
+                    let element = RArray::from_value(self.pinned(array))
+                        .map(|array| array.entry::<Value>(index))
+                        .transpose()?
+                        .unwrap_or_else(|| self.ruby.qnil().as_value());
+                    self.value(element)?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn value(&mut self, value: Value) -> Result<(), EncodeError> {
+        let ruby = self.ruby;
+        match rb_raw::ruby_type(ruby, value) {
+            RubyType::Array => {
+                self.array(value);
+                Ok(())
+            }
+            RubyType::Hash => self.hash(value),
+            RubyType::Data => self.data(value),
+            RubyType::Nil => {
+                self.writer.null();
+                Ok(())
+            }
+            RubyType::True => {
+                self.writer.bool(true);
+                Ok(())
+            }
+            RubyType::False => {
+                self.writer.bool(false);
+                Ok(())
+            }
+            RubyType::Bignum => self.bigint(value),
+            RubyType::Fixnum => {
+                self.writer
+                    .integer(Fixnum::from_value(value).map_or(0, Fixnum::to_i64));
+                Ok(())
+            }
+            RubyType::Float => {
+                self.writer
+                    .number(Float::from_value(value).map_or(f64::NAN, Float::to_f64));
+                Ok(())
+            }
+            RubyType::Symbol => {
+                self.string(rb_raw::sym2str(ruby, value));
+                Ok(())
+            }
+            RubyType::String => {
+                self.string(RString::from_value(value).unwrap_or_else(|| ruby.str_new("")));
+                Ok(())
+            }
+            RubyType::Object => self.object(value),
+            RubyType::Other(kind) => Err(EncodeError::unsupported(&format!(
+                "unsupported type {kind:x}"
+            ))),
+        }
+    }
+
+    fn array(&mut self, value: Value) {
+        if let Some(&id) = self.seen.get(&rb_raw::identity(value)) {
+            self.writer.object_ref(id);
+            return;
+        }
+        let len = RArray::from_value(value).map_or(0, RArray::len);
+        let count = length(len);
+        let id = self.writer.begin_array(count);
+        let array = self.pins.push(value);
+        self.seen.insert(rb_raw::identity(value), id);
+        self.work.push(Item::EndArray(count));
+        for index in (0..isize::try_from(len).unwrap_or(isize::MAX)).rev() {
+            self.work.push(Item::Element { array, index });
+        }
+    }
+
+    fn hash(&mut self, value: Value) -> Result<(), EncodeError> {
+        if let Some(&id) = self.seen.get(&rb_raw::identity(value)) {
+            self.writer.object_ref(id);
+            return Ok(());
+        }
+        self.pins.push(value);
+        let hash = RHash::from_value(value).unwrap_or_else(|| self.ruby.hash_new());
+        let mut pairs = Vec::new();
+        let mut keys_fit = true;
+        hash.foreach(|key: Value, item: Value| {
+            keys_fit &= matches!(
+                rb_raw::ruby_type(self.ruby, key),
+                RubyType::Fixnum | RubyType::String | RubyType::Symbol
+            );
+            pairs.push((self.pins.push(key), self.pins.push(item)));
+            Ok(ForEach::Continue)
+        })?;
+        let id = self.writer.begin_object();
+        self.seen.insert(rb_raw::identity(value), id);
+        if !keys_fit {
+            return Err(EncodeError::unsupported("TODO serialize as Map"));
+        }
+        self.work.push(Item::EndObject(length(pairs.len())));
+        for (key, item) in pairs.into_iter().rev() {
+            self.work.push(Item::Value(item));
+            self.work.push(Item::Value(key));
+        }
+        Ok(())
+    }
+
+    // Dates and typed arrays are objects V8 numbers, so a Ruby object sent
+    // twice goes the second time as a reference, as Arrays and Hashes do.
+    fn repeated(&mut self, value: Value) -> bool {
+        if let Some(&id) = self.seen.get(&rb_raw::identity(value)) {
+            self.writer.object_ref(id);
+            return true;
+        }
+        false
+    }
+
+    fn remember(&mut self, value: Value, id: u32) {
+        self.pins.push(value);
+        self.seen.insert(rb_raw::identity(value), id);
+    }
+
+    fn data(&mut self, value: Value) -> Result<(), EncodeError> {
+        let ruby = self.ruby;
+        if self.repeated(value) {
+            return Ok(());
+        }
+        let mut time = value;
+        if DATE_TIME.get(ruby).is_some_and(|date_time| {
+            rb_raw::identity(value.class().as_value()) == rb_raw::identity(date_time)
+        }) {
+            time = value.funcall("to_time", ())?;
+            self.pins.push(time);
+        }
+        if rb_raw::identity(time.class().as_value())
+            == rb_raw::identity(ruby.class_time().as_value())
+        {
+            let id = self.date(time)?;
+            self.remember(value, id);
+        } else {
+            self.writer.utf8(b"Undefined Conversion");
+        }
+        Ok(())
+    }
+
+    fn object(&mut self, value: Value) -> Result<(), EncodeError> {
+        let ruby = self.ruby;
+        if self.repeated(value) {
+            return Ok(());
+        }
+        if value.respond_to("to_time", false)? {
+            let time: Value = value.funcall("to_time", ())?;
+            self.pins.push(time);
+            if time.is_kind_of(ruby.class_time()) {
+                let id = self.date(time)?;
+                self.remember(value, id);
+                return Ok(());
+            }
+            return Err(EncodeError::unsupported(&format!(
+                "unsupported type {}",
+                rb_raw::class_name(ruby, time)
+            )));
+        }
+        if value.is_kind_of(BINARY.get(ruby)) {
+            let data: Value = RObject::from_value(value)
+                .map(|object| object.ivar_get("@data"))
+                .transpose()?
+                .unwrap_or_else(|| ruby.qnil().as_value());
+            let data = rb_raw::expect_string(ruby, data)?;
+            let id = rb_raw::with_string_bytes(ruby, data, |bytes| self.writer.uint8_array(bytes));
+            self.remember(value, id);
+            return Ok(());
+        }
+        Err(EncodeError::unsupported(&format!(
+            "unsupported type {}",
+            rb_raw::class_name(ruby, value)
+        )))
+    }
+
+    // mini_racer reads the time as a timeval, whole microseconds.
+    #[expect(
+        clippy::cast_precision_loss,
+        reason = "mini_racer does the same arithmetic in doubles"
+    )]
+    #[expect(
+        clippy::suboptimal_flops,
+        reason = "a fused multiply-add would round differently"
+    )]
+    fn date(&mut self, value: Value) -> Result<u32, EncodeError> {
+        let time = Time::from_value(value)
+            .ok_or_else(|| EncodeError::unsupported("unsupported type Time"))?
+            .timespec()?;
+        let micros = time.tv_nsec / 1000;
+        Ok(self
+            .writer
+            .date(time.tv_sec as f64 * 1e3 + micros as f64 / 1e3))
+    }
+
+    fn bigint(&mut self, value: Value) -> Result<(), EncodeError> {
+        let Some((negative, digits)) = rb_raw::integer_words(self.ruby, value, BIGINT_MAX_WORDS)?
+        else {
+            return Err(EncodeError::unsupported("bigint too big"));
+        };
+        self.writer
+            .bigint(negative, &digits)
+            .map_err(|error| EncodeError::unsupported(&error.to_string()))
+    }
+
+    fn string(&mut self, text: RString) {
+        let encoding = RbEncoding::from(text.enc_get());
+        rb_raw::with_string_bytes(self.ruby, text, |bytes| match encoding.name() {
+            "ISO-8859-1" => self.writer.latin1(bytes),
+            "UTF-16LE" => self.writer.utf16le(bytes),
+            _ => self.writer.utf8(bytes),
+        });
+    }
+}

data/ext/mini_racer_rs/src/errors.rs

@@ -0,0 +1,156 @@
+use magnus::value::ReprValue;
+use magnus::{Class, Error, ExceptionClass, Module, Object, RModule, RObject, Ruby, Value};
+use mini_racer_engine::{EngineError, FlagError, JsErrorKind, TerminationCause};
+
+use crate::export;
+use crate::gc_root::StaticRoot;
+
+// const_get on a module falls back to Object, so a missing MiniRacer::RuntimeError
+// would silently resolve to ::RuntimeError; the inspect check rejects that.
+fn class(ruby: &Ruby, module: &str, name: &str) -> Result<ExceptionClass, Error> {
+    let found: ExceptionClass = ruby
+        .class_object()
+        .const_get::<_, RModule>(module)?
+        .const_get(name)?;
+    let expected = format!("{module}::{name}");
+    if found.inspect() == expected {
+        Ok(found)
+    } else {
+        Err(Error::new(
+            ruby.exception_load_error(),
+            format!("{expected} is not defined"),
+        ))
+    }
+}
+
+#[expect(
+    clippy::expect_used,
+    reason = "errors::init resolved the class, and a root initializer cannot return an error"
+)]
+fn resolved(ruby: &Ruby, module: &str, name: &str) -> ExceptionClass {
+    class(ruby, module, name).expect("errors::init resolved this class")
+}
+
+macro_rules! roots {
+    ($($root:ident = $module:literal :: $name:literal;)*) => {
+        $(
+            static $root: StaticRoot<ExceptionClass> =
+                StaticRoot::new(|ruby| resolved(ruby, $module, $name));
+        )*
+
+        pub fn init(ruby: &Ruby) -> Result<(), Error> {
+            $( class(ruby, $module, $name)?; )*
+            SCRIPT.get(ruby).define_method("cause", export!(method cause, 0))?;
+            Ok(())
+        }
+    };
+}
+
+roots! {
+    PARSE = "MiniRacer"::"ParseError";
+    RUNTIME = "MiniRacer"::"RuntimeError";
+    SCRIPT = "MiniRacer"::"ScriptError";
+    TERMINATED = "MiniRacer"::"ScriptTerminatedError";
+    OUT_OF_MEMORY = "MiniRacer"::"V8OutOfMemoryError";
+    DISPOSED = "MiniRacer"::"ContextDisposedError";
+    PLATFORM_INITIALIZED = "MiniRacer"::"PlatformAlreadyInitialized";
+    INTERNAL = "MiniRacer"::"InternalError";
+    SNAPSHOT = "MiniRacer"::"SnapshotError";
+}
+
+pub fn engine(ruby: &Ruby, error: EngineError) -> Error {
+    match error {
+        EngineError::Js(js) => {
+            let root = match js.kind {
+                JsErrorKind::Parse => &PARSE,
+                JsErrorKind::Runtime => &RUNTIME,
+                JsErrorKind::Internal => &INTERNAL,
+                JsErrorKind::Terminated(
+                    TerminationCause::Stop
+                    | TerminationCause::Timeout
+                    | TerminationCause::Cancelled,
+                ) => &TERMINATED,
+                JsErrorKind::Terminated(
+                    TerminationCause::MaxMemory | TerminationCause::HeapExhausted,
+                ) => &OUT_OF_MEMORY,
+                // mini_racer raises its disposed error when a callback's
+                // exception escapes but none is kept for it.
+                JsErrorKind::HostException => {
+                    return raised(ruby, DISPOSED.get(ruby), "disposed context");
+                }
+            };
+            Error::new(root.get(ruby), js.message)
+        }
+        EngineError::Disposed => raised(ruby, DISPOSED.get(ruby), "disposed context"),
+        EngineError::Orphaned | EngineError::DisposeBusy => {
+            raised(ruby, RUNTIME.get(ruby), error.to_string())
+        }
+        EngineError::Busy => raised(ruby, INTERNAL.get(ruby), error.to_string()),
+        EngineError::Internal(message) => raised(ruby, INTERNAL.get(ruby), &message),
+        EngineError::Snapshot(message) => snapshot(ruby, &message),
+        EngineError::InvalidSnapshot(_) => raised(ruby, SNAPSHOT.get(ruby), error.to_string()),
+    }
+}
+
+pub fn flag(ruby: &Ruby, error: FlagError) -> Error {
+    match error {
+        FlagError::Nul | FlagError::TooLong => {
+            raised(ruby, ruby.exception_arg_error(), error.to_string())
+        }
+        FlagError::AlreadyInitialized => {
+            raised(ruby, PLATFORM_INITIALIZED.get(ruby), error.to_string())
+        }
+    }
+}
+
+// A JavaScript error object decoded into Ruby keeps its cause here, as in
+// mini_racer, rather than in the cause Ruby gives a raised exception.
+fn cause(_ruby: &Ruby, rb_self: RObject) -> Result<Value, Error> {
+    rb_self.ivar_get("@cause")
+}
+
+pub fn script_error(ruby: &Ruby) -> ExceptionClass {
+    SCRIPT.get(ruby)
+}
+
+// mini_racer raises these with rb_raise from C strings, so their messages are
+// binary strings; only messages that come from JavaScript are UTF-8.
+pub fn raised(ruby: &Ruby, class: ExceptionClass, message: impl AsRef<[u8]>) -> Error {
+    class
+        .new_instance((ruby.str_from_slice(message.as_ref()),))
+        .map_or_else(|error| error, Error::from)
+}
+
+// mini_racer's V8 refuses an odd-length UTF-16LE string in a request with this
+// JavaScript error.
+pub fn undeserializable(ruby: &Ruby) -> Error {
+    Error::new(
+        INTERNAL.get(ruby),
+        "Error: Unable to deserialize cloned data.",
+    )
+}
+
+// mini_racer reads a snapshot error without transcoding: text that fits in
+// Latin-1 arrives as those bytes in a binary String, anything wider as UTF-8.
+pub fn snapshot(ruby: &Ruby, message: &str) -> Error {
+    let latin1: Option<Vec<u8>> = message
+        .chars()
+        .map(|c| u8::try_from(u32::from(c)).ok())
+        .collect();
+    let text = latin1.map_or_else(
+        || ruby.str_new(message),
+        |bytes| ruby.str_from_slice(&bytes),
+    );
+    SNAPSHOT
+        .get(ruby)
+        .new_instance((text,))
+        .map_or_else(|error| error, Error::from)
+}
+
+pub fn runtime(ruby: &Ruby, message: impl AsRef<[u8]>) -> Error {
+    raised(ruby, RUNTIME.get(ruby), message)
+}
+
+pub fn internal(ruby: &Ruby, message: impl AsRef<[u8]>) -> Error {
+    raised(ruby, INTERNAL.get(ruby), message)
+}

data/ext/mini_racer_rs/src/fork.rs

@@ -0,0 +1,31 @@
+use magnus::{Error, Module, Object, RModule, Ruby, Value};
+use mini_racer_engine::process::fork;
+
+use crate::{export, rb_raw};
+
+pub fn init(ruby: &Ruby, rs: RModule) -> Result<(), Error> {
+    let hook = rs.define_module("ForkHook")?;
+    hook.define_method("_fork", export!(method fork_hook, 0))?;
+    hook.define_method("daemon", export!(method daemon_hook, -1))?;
+    let process: RModule = ruby.class_object().const_get("Process")?;
+    process.singleton_class()?.prepend_module(hook)?;
+    Ok(())
+}
+
+// Process._fork, which every fork from Ruby goes through except
+// Process.daemon's. The engine's own fork handlers, inside fork() itself, wait
+// for the runners only on forks marked this way, whose child runs Ruby.
+fn fork_hook(ruby: &Ruby, _process: Value) -> Result<Value, Error> {
+    forking(ruby, &[])
+}
+
+fn daemon_hook(ruby: &Ruby, _process: Value, args: &[Value]) -> Result<Value, Error> {
+    forking(ruby, args)
+}
+
+fn forking(ruby: &Ruby, args: &[Value]) -> Result<Value, Error> {
+    fork::intend(true);
+    let forked = rb_raw::call_super(ruby, args);
+    fork::intend(false);
+    forked
+}

data/ext/mini_racer_rs/src/gc_root.rs

@@ -0,0 +1,117 @@
+use std::cell::{Cell, RefCell};
+use std::sync::OnceLock;
+
+use magnus::gc::Marker;
+use magnus::typed_data::Obj;
+use magnus::value::{Lazy, Opaque, ReprValue};
+use magnus::{Class, DataTypeFunctions, Error, Module, RModule, Ruby, TypedData, Value};
+
+pub struct StaticRoot<T: ReprValue>(Lazy<T>);
+
+impl<T: ReprValue> StaticRoot<T> {
+    pub const fn new(init: fn(&Ruby) -> T) -> Self {
+        Self(Lazy::new(init))
+    }
+
+    pub fn get(&self, ruby: &Ruby) -> T {
+        ruby.get_inner(&self.0)
+    }
+}
+
+/// A Ruby value held by a wrapped Rust object, kept alive and pinned by the
+/// owner's mark function. Only touched under the GVL.
+pub struct OwnedRoot<T: ReprValue>(Cell<Option<Opaque<T>>>);
+
+impl<T: ReprValue> Default for OwnedRoot<T> {
+    fn default() -> Self {
+        Self(Cell::new(None))
+    }
+}
+
+impl<T: ReprValue> OwnedRoot<T> {
+    pub fn set(&self, _ruby: &Ruby, value: T) {
+        self.0.set(Some(Opaque::from(value)));
+    }
+
+    pub fn get(&self, ruby: &Ruby) -> Option<T> {
+        self.0.get().map(|value| ruby.get_inner(value))
+    }
+
+    pub fn take(&self, ruby: &Ruby) -> Option<T> {
+        self.0.take().map(|value| ruby.get_inner(value))
+    }
+
+    pub fn mark(&self, marker: &Marker) {
+        if let Some(value) = self.0.get() {
+            marker.mark(value);
+        }
+    }
+}
+
+/// A Ruby value found after startup, such as a class defined by a later
+/// require, kept alive for the life of the process once set.
+pub struct OnceRoot<T: ReprValue>(OnceLock<Opaque<T>>);
+
+impl<T: ReprValue> OnceRoot<T> {
+    pub const fn new() -> Self {
+        Self(OnceLock::new())
+    }
+
+    pub fn get(&self, ruby: &Ruby) -> Option<T> {
+        self.0.get().map(|value| ruby.get_inner(*value))
+    }
+
+    pub fn set(&self, ruby: &Ruby, value: T) {
+        if self.0.set(Opaque::from(value)).is_ok() {
+            ruby.gc_register_mark_object(value);
+        }
+    }
+}
+
+/// Ruby values a Rust loop holds while it may call Ruby, which can collect and
+/// compact. The holder's mark pins every value, so each stays alive at the
+/// same address and can serve as an identity key. Only touched under the GVL,
+/// and no borrow spans a Ruby call, so the mark always finds the list free.
+#[derive(Default, TypedData)]
+#[magnus(class = "MiniRacerRs::Pins", free_immediately, mark)]
+pub struct Pins(RefCell<Vec<Opaque<Value>>>);
+
+impl DataTypeFunctions for Pins {
+    // A borrow at mark time would leave every value unpinned and free to move,
+    // so it ends the process rather than corrupt the encode.
+    fn mark(&self, marker: &Marker) {
+        let Ok(values) = self.0.try_borrow() else {
+            std::process::abort();
+        };
+        for value in values.iter() {
+            marker.mark(*value);
+        }
+    }
+}
+
+impl Pins {
+    /// Keep using the returned `Obj` while the values are needed; a reference
+    /// into its data alone does not keep the holder alive.
+    pub fn new(ruby: &Ruby) -> Obj<Self> {
+        ruby.obj_wrap(Self::default())
+    }
+
+    pub fn push(&self, value: Value) -> usize {
+        let mut values = self.0.borrow_mut();
+        values.push(Opaque::from(value));
+        values.len().saturating_sub(1)
+    }
+
+    pub fn get(&self, ruby: &Ruby, index: usize) -> Option<Value> {
+        self.0
+            .borrow()
+            .get(index)
+            .map(|value| ruby.get_inner(*value))
+    }
+}
+
+pub fn init(ruby: &Ruby, rs: RModule) -> Result<(), Error> {
+    let class = rs.define_class("Pins", ruby.class_object())?;
+    class.undef_default_alloc_func();
+    Ok(())
+}

data/ext/mini_racer_rs/src/guard.rs

@@ -0,0 +1,7 @@
+use std::panic::{AssertUnwindSafe, catch_unwind};
+
+pub struct Panicked;
+
+pub fn guard<R>(f: impl FnOnce() -> R) -> Result<R, Panicked> {
+    catch_unwind(AssertUnwindSafe(f)).map_err(|_| Panicked)
+}