From 0e2a7b35d25b6c3c3760c067d3dd8f7047a4a470 Mon Sep 17 00:00:00 2001 From: Hare Date: Thu, 9 Jul 2026 18:34:41 +0900 Subject: [PATCH] Add language tools package --- Cargo.lock | 51 ++ Cargo.toml | 1 + crates/decodal-language-tools/Cargo.toml | 25 + crates/decodal-language-tools/src/lib.rs | 851 ++++++++++++++++++ doc/manual/souce/components.md | 19 + doc/manual/souce/development.md | 40 +- packages/decodal-language-tools/.gitignore | 1 + packages/decodal-language-tools/README.md | 39 + .../decodal_language_tools.d.ts | 38 + .../decodal_language_tools.js | 209 +++++ .../decodal_language_tools_bg.wasm | Bin 0 -> 133047 bytes .../decodal_language_tools_bg.wasm.d.ts | 9 + packages/decodal-language-tools/jsr.json | 15 + packages/decodal-language-tools/package.json | 27 + site/decodal-site/package-lock.json | 9 + site/decodal-site/package.json | 5 +- .../prepare-language-tools-package.mjs | 76 ++ site/decodal-site/src/pages/index.astro | 12 +- site/decodal-site/src/pages/playground.astro | 1 + site/decodal-site/src/scripts/playground.js | 22 +- 20 files changed, 1434 insertions(+), 16 deletions(-) create mode 100644 crates/decodal-language-tools/Cargo.toml create mode 100644 crates/decodal-language-tools/src/lib.rs create mode 100644 packages/decodal-language-tools/.gitignore create mode 100644 packages/decodal-language-tools/README.md create mode 100644 packages/decodal-language-tools/decodal_language_tools.d.ts create mode 100644 packages/decodal-language-tools/decodal_language_tools.js create mode 100644 packages/decodal-language-tools/decodal_language_tools_bg.wasm create mode 100644 packages/decodal-language-tools/decodal_language_tools_bg.wasm.d.ts create mode 100644 packages/decodal-language-tools/jsr.json create mode 100644 packages/decodal-language-tools/package.json create mode 100644 site/decodal-site/scripts/prepare-language-tools-package.mjs diff --git a/Cargo.lock b/Cargo.lock index 4ed4393..ffe211f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -17,6 +17,16 @@ version = "3.20.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" +[[package]] +name = "cc" +version = "1.2.66" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f5d6cac793997bd970000024b2934968efe83b382de4fdcf4fcb46b6ee4ad996" +dependencies = [ + "find-msvc-tools", + "shlex", +] + [[package]] name = "cfg-if" version = "1.0.4" @@ -48,6 +58,17 @@ dependencies = [ "syn", ] +[[package]] +name = "decodal-language-tools" +version = "0.1.2" +dependencies = [ + "decodal", + "serde_json", + "tree-sitter", + "tree-sitter-decodal", + "wasm-bindgen", +] + [[package]] name = "decodal-wasm" version = "0.1.2" @@ -57,6 +78,12 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + [[package]] name = "itoa" version = "1.0.18" @@ -170,6 +197,12 @@ dependencies = [ "zmij", ] +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + [[package]] name = "syn" version = "2.0.117" @@ -181,6 +214,24 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "tree-sitter" +version = "0.22.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df7cc499ceadd4dcdf7ec6d4cbc34ece92c3fa07821e287aedecd4416c516dca" +dependencies = [ + "cc", + "regex", +] + +[[package]] +name = "tree-sitter-decodal" +version = "0.0.1" +dependencies = [ + "cc", + "tree-sitter", +] + [[package]] name = "unicode-ident" version = "1.0.24" diff --git a/Cargo.toml b/Cargo.toml index d3b63c2..7f1149a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,6 +4,7 @@ members = [ "crates/decodal-cli", "crates/decodal-wasm", "crates/decodal-derive", + "crates/decodal-language-tools", ] resolver = "2" diff --git a/crates/decodal-language-tools/Cargo.toml b/crates/decodal-language-tools/Cargo.toml new file mode 100644 index 0000000..6db03b4 --- /dev/null +++ b/crates/decodal-language-tools/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "decodal-language-tools" +version.workspace = true +edition.workspace = true +rust-version.workspace = true +license.workspace = true +repository.workspace = true +readme.workspace = true +description = "Source-level language tooling for Decodal." +keywords = ["decodal", "formatter", "lsp", "tree-sitter"] +categories = ["development-tools", "text-processing"] +publish = false + +[lib] +crate-type = ["cdylib", "rlib"] + +[dependencies] +decodal = { version = "0.1.2", path = "../decodal-core" } +serde_json.workspace = true +tree-sitter = "0.22.6" +tree-sitter-decodal = { path = "../../editors/tree-sitter-decodal" } +wasm-bindgen.workspace = true + +[package.metadata.wasm-pack.profile.release] +wasm-opt = false diff --git a/crates/decodal-language-tools/src/lib.rs b/crates/decodal-language-tools/src/lib.rs new file mode 100644 index 0000000..02eaf9c --- /dev/null +++ b/crates/decodal-language-tools/src/lib.rs @@ -0,0 +1,851 @@ +use std::{error::Error, fmt}; + +#[cfg(not(target_arch = "wasm32"))] +use tree_sitter::{Node, Parser, TreeCursor}; +use wasm_bindgen::prelude::*; + +const INDENT: usize = 4; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FormatError { + message: String, +} + +impl FormatError { + fn new(message: impl Into) -> Self { + Self { + message: message.into(), + } + } + + pub fn message(&self) -> &str { + &self.message + } +} + +impl fmt::Display for FormatError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(&self.message) + } +} + +impl Error for FormatError {} + +pub fn format_source(source: &str) -> Result { + decodal::parse_source(source) + .map_err(|diagnostic| FormatError::new(format!("parse error: {}", diagnostic.message)))?; + format_source_impl(source) +} + +#[cfg(not(target_arch = "wasm32"))] +fn format_source_impl(source: &str) -> Result { + let mut parser = Parser::new(); + parser + .set_language(&tree_sitter_decodal::language()) + .map_err(|error| { + FormatError::new(format!("failed to load tree-sitter grammar: {error}")) + })?; + let tree = parser + .parse(source, None) + .ok_or_else(|| FormatError::new("tree-sitter failed to parse source"))?; + let root = tree.root_node(); + if root.has_error() { + return Err(FormatError::new( + "parse error: source contains tree-sitter errors", + )); + } + + let mut formatter = Formatter::new(source); + let mut out = formatter.format_source_file(root); + if !out.ends_with('\n') { + out.push('\n'); + } + Ok(out) +} + +#[wasm_bindgen(js_name = formatSource)] +pub fn format_source_json(source: &str) -> String { + match format_source(source) { + Ok(formatted) => serde_json::json!({ "ok": true, "source": formatted }).to_string(), + Err(error) => serde_json::json!({ "ok": false, "error": error.message() }).to_string(), + } +} + +#[cfg(target_arch = "wasm32")] +fn format_source_impl(source: &str) -> Result { + Ok(LexicalFormatter::new(source).format()) +} + +#[cfg(target_arch = "wasm32")] +struct LexicalFormatter<'a> { + chars: core::iter::Peekable>, + out: String, + indent: usize, + line_start: bool, +} + +#[cfg(target_arch = "wasm32")] +impl<'a> LexicalFormatter<'a> { + fn new(source: &'a str) -> Self { + Self { + chars: source.chars().peekable(), + out: String::new(), + indent: 0, + line_start: true, + } + } + + fn format(mut self) -> String { + while let Some(ch) = self.chars.next() { + match ch { + ' ' | '\t' | '\r' | '\n' => self.consume_whitespace(ch), + '#' => self.write_comment(), + '"' => self.write_string(), + '{' => self.open_block('{'), + '[' => self.open_block('['), + '}' => self.close_block('}'), + ']' => self.close_block(']'), + ';' => self.end_statement(), + ',' => self.write_comma(), + '.' => self.write_compact('.'), + ':' => self.write_spaced_operator(":"), + '(' => self.write_compact('('), + ')' => self.write_compact(')'), + '+' | '-' | '*' | '/' | '=' | '!' | '&' | '|' | '>' | '<' => { + self.write_operator(ch) + } + _ => self.write_word(ch), + } + } + self.trim_trailing_spaces(); + if !self.out.ends_with('\n') { + self.out.push('\n'); + } + self.out + } + + fn consume_whitespace(&mut self, ch: char) { + if ch == '\n' && self.out.ends_with('\n') && !self.out.ends_with("\n\n") { + self.out.push('\n'); + self.line_start = true; + } + } + + fn write_comment(&mut self) { + if self.line_start { + self.write_indent(); + } else { + self.ensure_space(); + } + self.out.push('#'); + for ch in self.chars.by_ref() { + if ch == '\n' { + break; + } + self.out.push(ch); + } + self.trim_trailing_spaces(); + self.out.push('\n'); + self.line_start = true; + } + + fn write_string(&mut self) { + self.write_indent_if_needed(); + self.ensure_word_boundary(); + self.out.push('"'); + let mut escaped = false; + for ch in self.chars.by_ref() { + self.out.push(ch); + if escaped { + escaped = false; + } else if ch == '\\' { + escaped = true; + } else if ch == '"' { + break; + } + } + } + + fn open_block(&mut self, ch: char) { + self.trim_trailing_spaces(); + self.out.push(' '); + self.out.push(ch); + self.out.push('\n'); + self.indent += INDENT; + self.line_start = true; + } + + fn close_block(&mut self, ch: char) { + self.trim_trailing_spaces(); + if !self.out.ends_with('\n') { + self.out.push('\n'); + } + self.indent = self.indent.saturating_sub(INDENT); + self.write_indent(); + self.out.push(ch); + self.line_start = false; + } + + fn end_statement(&mut self) { + self.trim_trailing_spaces(); + self.out.push(';'); + self.out.push('\n'); + self.line_start = true; + } + + fn write_comma(&mut self) { + self.trim_trailing_spaces(); + self.out.push(','); + self.out.push(' '); + self.line_start = false; + } + + fn write_operator(&mut self, ch: char) { + let mut op = String::new(); + op.push(ch); + if let Some(next) = self.chars.peek().copied() { + let two_char = matches!( + (ch, next), + ('=', '=') + | ('!', '=') + | ('>', '=') + | ('<', '=') + | ('+', '+') + | ('/', '/') + | ('&', '&') + | ('|', '|') + | ('=', '>') + ); + if two_char { + op.push(next); + self.chars.next(); + } + } + self.write_spaced_operator(&op); + } + + fn write_spaced_operator(&mut self, op: &str) { + self.trim_trailing_spaces(); + self.ensure_space(); + self.out.push_str(op); + self.out.push(' '); + self.line_start = false; + } + + fn write_compact(&mut self, ch: char) { + self.trim_trailing_spaces(); + self.write_indent_if_needed(); + self.out.push(ch); + self.line_start = false; + } + + fn write_word(&mut self, first: char) { + self.write_indent_if_needed(); + self.ensure_word_boundary(); + self.out.push(first); + while let Some(next) = self.chars.peek().copied() { + if next.is_alphanumeric() || next == '_' { + self.out.push(next); + self.chars.next(); + } else { + break; + } + } + self.line_start = false; + } + + fn write_indent_if_needed(&mut self) { + if self.line_start { + self.write_indent(); + self.line_start = false; + } + } + + fn write_indent(&mut self) { + for _ in 0..self.indent { + self.out.push(' '); + } + } + + fn ensure_word_boundary(&mut self) { + let needs_space = self + .out + .chars() + .last() + .is_some_and(|ch| ch.is_alphanumeric() || matches!(ch, '_' | '"')); + if needs_space { + self.out.push(' '); + } + } + + fn ensure_space(&mut self) { + let needs_space = self + .out + .chars() + .last() + .is_some_and(|ch| !matches!(ch, ' ' | '\n' | '.' | '(' | '[')); + if needs_space { + self.out.push(' '); + } + } + + fn trim_trailing_spaces(&mut self) { + while self.out.ends_with(' ') || self.out.ends_with('\t') { + self.out.pop(); + } + } +} + +#[cfg(not(target_arch = "wasm32"))] +struct Formatter<'a> { + source: &'a str, +} + +#[cfg(not(target_arch = "wasm32"))] +impl<'a> Formatter<'a> { + fn new(source: &'a str) -> Self { + Self { source } + } + + fn format_source_file(&mut self, node: Node<'a>) -> String { + let mut out = String::new(); + let children = named_children(node); + self.write_statement_list(&mut out, &children, 0); + out + } + + fn write_statement_list(&mut self, out: &mut String, children: &[Node<'a>], indent: usize) { + let mut pending_comments = Vec::new(); + let mut pending_blank = false; + let mut previous_end = 0; + let mut previous_statement_end_row = None; + + for &child in children { + let is_trailing_comment = child.kind() == "comment" + && previous_statement_end_row == Some(child.start_position().row); + if previous_statement_end_row.is_some() && !is_trailing_comment { + if !out.ends_with('\n') { + out.push('\n'); + } + previous_statement_end_row = None; + } + + if previous_end > 0 && has_blank_line(self.slice(previous_end, child.start_byte())) { + pending_blank = true; + } + + if child.kind() == "comment" { + if is_trailing_comment { + if !out.ends_with(' ') { + out.push(' '); + } + out.push_str(self.raw_trimmed(child)); + out.push('\n'); + previous_statement_end_row = None; + } else { + pending_comments.push(child); + } + previous_end = child.end_byte(); + continue; + } + + if pending_blank && !out.is_empty() && !out.ends_with("\n\n") { + out.push('\n'); + } + pending_blank = false; + + for comment in pending_comments.drain(..) { + write_indent(out, indent); + out.push_str(self.raw_trimmed(comment)); + out.push('\n'); + } + + write_indent(out, indent); + self.write_statement(out, child, indent); + previous_statement_end_row = Some(child.end_position().row); + previous_end = child.end_byte(); + } + + if previous_statement_end_row.is_some() && !out.ends_with('\n') { + out.push('\n'); + } + + if pending_blank && !out.is_empty() && !out.ends_with("\n\n") { + out.push('\n'); + } + for comment in pending_comments { + write_indent(out, indent); + out.push_str(self.raw_trimmed(comment)); + out.push('\n'); + } + } + + fn write_statement(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + match node.kind() { + "field_definition" => { + self.write_field_definition(out, node, indent); + out.push(';'); + } + _ => { + self.write_expr(out, node, indent, 0); + out.push(';'); + } + } + } + + fn write_field_definition(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + if let Some(path) = node.child_by_field_name("path") { + self.write_field_path(out, path); + } else { + out.push_str(self.raw_trimmed(node)); + return; + } + out.push_str(" = "); + if let Some(value) = node.child_by_field_name("value") { + self.write_expr(out, value, indent, 0); + } + } + + fn write_field_path(&mut self, out: &mut String, node: Node<'a>) { + let identifiers: Vec<_> = named_children(node) + .into_iter() + .filter(|child| child.kind() == "identifier") + .collect(); + if identifiers.is_empty() { + out.push_str(self.raw_trimmed(node)); + return; + } + for (index, identifier) in identifiers.into_iter().enumerate() { + if index > 0 { + out.push('.'); + } + out.push_str(self.raw_trimmed(identifier)); + } + } + + fn write_expr(&mut self, out: &mut String, node: Node<'a>, indent: usize, parent_prec: u8) { + if expression_contains_comment(node) + && !matches!( + node.kind(), + "object" | "array" | "let_expression" | "match_expression" + ) + { + out.push_str(self.raw_trimmed(node)); + return; + } + + let prec = self.precedence(node); + let parenthesize = prec < parent_prec; + if parenthesize { + out.push('('); + } + + match node.kind() { + "literal" => { + if let Some(child) = named_children(node).first().copied() { + out.push_str(self.raw_trimmed(child)); + } else { + out.push_str(self.raw_trimmed(node)); + } + } + "identifier" | "string" | "integer" | "float" | "boolean" | "regex_literal" => { + out.push_str(self.raw_trimmed(node)); + } + "comparison_constraint" => self.write_comparison_constraint(out, node, indent), + "object" => self.write_object(out, node, indent), + "array" => self.write_array(out, node, indent), + "let_expression" => self.write_let(out, node, indent), + "function_expression" => self.write_function(out, node, indent), + "match_expression" => self.write_match(out, node, indent), + "import_expression" => self.write_import(out, node), + "parenthesized_expression" => { + out.push('('); + if let Some(expr) = named_children(node) + .into_iter() + .find(|child| child.kind() != "comment") + { + self.write_expr(out, expr, indent, 0); + } + out.push(')'); + } + "call_expression" => self.write_call(out, node, indent), + "path_expression" => self.write_path(out, node, indent), + "unary_expression" => self.write_unary(out, node, indent), + "binary_expression" | "default_expression" => { + self.write_binary_like(out, node, indent, prec) + } + _ => out.push_str(self.raw_trimmed(node)), + } + + if parenthesize { + out.push(')'); + } + } + + fn write_object(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + let children = named_children(node); + if children.is_empty() { + out.push_str("{}"); + return; + } + out.push('{'); + out.push('\n'); + self.write_statement_list(out, &children, indent + INDENT); + write_indent(out, indent); + out.push('}'); + } + + fn write_array(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + let children = named_children(node); + if children.is_empty() { + out.push_str("[]"); + return; + } + let has_comment = children.iter().any(|child| child.kind() == "comment"); + let inline = !has_comment && children.iter().all(|child| is_inline_expr(*child)); + if inline { + out.push('['); + for (index, child) in children.into_iter().enumerate() { + if index > 0 { + out.push_str(", "); + } + self.write_expr(out, child, indent, 0); + } + out.push(']'); + return; + } + + out.push('['); + out.push('\n'); + let mut pending_comments = Vec::new(); + for child in children { + if child.kind() == "comment" { + pending_comments.push(child); + continue; + } + for comment in pending_comments.drain(..) { + write_indent(out, indent + INDENT); + out.push_str(self.raw_trimmed(comment)); + out.push('\n'); + } + write_indent(out, indent + INDENT); + self.write_expr(out, child, indent + INDENT, 0); + out.push_str(",\n"); + } + for comment in pending_comments { + write_indent(out, indent + INDENT); + out.push_str(self.raw_trimmed(comment)); + out.push('\n'); + } + write_indent(out, indent); + out.push(']'); + } + + fn write_let(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + let body = node.child_by_field_name("body"); + out.push_str("let"); + out.push('\n'); + let children: Vec<_> = named_children(node) + .into_iter() + .filter(|child| Some(*child) != body) + .collect(); + self.write_statement_list(out, &children, indent + INDENT); + write_indent(out, indent); + out.push_str("in"); + if let Some(body) = body { + out.push('\n'); + write_indent(out, indent + INDENT); + self.write_expr(out, body, indent + INDENT, 0); + } + } + + fn write_function(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + let body = node.child_by_field_name("body"); + let params: Vec<_> = named_children(node) + .into_iter() + .filter(|child| child.kind() == "parameter") + .collect(); + out.push('('); + for (index, param) in params.into_iter().enumerate() { + if index > 0 { + out.push_str(", "); + } + self.write_parameter(out, param, indent); + } + out.push_str(") =>"); + if let Some(body) = body { + if is_inline_expr(body) { + out.push(' '); + self.write_expr(out, body, indent, 0); + } else { + out.push('\n'); + write_indent(out, indent + INDENT); + self.write_expr(out, body, indent + INDENT, 0); + } + } + } + + fn write_parameter(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + if let Some(name) = node.child_by_field_name("name") { + out.push_str(self.raw_trimmed(name)); + } + if let Some(constraint) = node.child_by_field_name("constraint") { + out.push_str(": "); + self.write_expr(out, constraint, indent, 0); + } + } + + fn write_match(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + out.push_str("match "); + if let Some(scrutinee) = node.child_by_field_name("scrutinee") { + self.write_expr(out, scrutinee, indent, 0); + } + out.push_str(" {"); + let children: Vec<_> = named_children(node) + .into_iter() + .filter(|child| child.kind() == "match_arm" || child.kind() == "comment") + .collect(); + if !children.is_empty() { + out.push('\n'); + self.write_match_arms(out, &children, indent + INDENT); + write_indent(out, indent); + } + out.push('}'); + } + + fn write_match_arms(&mut self, out: &mut String, children: &[Node<'a>], indent: usize) { + let mut pending_comments = Vec::new(); + for &child in children { + if child.kind() == "comment" { + pending_comments.push(child); + continue; + } + for comment in pending_comments.drain(..) { + write_indent(out, indent); + out.push_str(self.raw_trimmed(comment)); + out.push('\n'); + } + write_indent(out, indent); + if let Some(pattern) = child.child_by_field_name("pattern") { + self.write_expr(out, pattern, indent, 0); + } + out.push_str(": "); + if let Some(body) = child.child_by_field_name("body") { + self.write_expr(out, body, indent, 0); + } + out.push_str(";\n"); + } + for comment in pending_comments { + write_indent(out, indent); + out.push_str(self.raw_trimmed(comment)); + out.push('\n'); + } + } + + fn write_import(&mut self, out: &mut String, node: Node<'a>) { + out.push_str("import "); + if let Some(specifier) = node.child_by_field_name("specifier") { + out.push_str(self.raw_trimmed(specifier)); + } + } + + fn write_call(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + let callee = node.child_by_field_name("function"); + if let Some(callee) = callee { + self.write_expr(out, callee, indent, self.precedence(node)); + } + out.push('('); + let args: Vec<_> = named_children(node) + .into_iter() + .filter(|child| Some(*child) != callee && child.kind() != "comment") + .collect(); + for (index, arg) in args.into_iter().enumerate() { + if index > 0 { + out.push_str(", "); + } + self.write_expr(out, arg, indent, 0); + } + out.push(')'); + } + + fn write_path(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + if let Some(object) = node.child_by_field_name("object") { + self.write_expr(out, object, indent, self.precedence(node)); + } + out.push('.'); + if let Some(field) = node.child_by_field_name("field") { + out.push_str(self.raw_trimmed(field)); + } + } + + fn write_unary(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + if let Some(operand) = node.child_by_field_name("operand") { + let operator = self.slice(node.start_byte(), operand.start_byte()).trim(); + out.push_str(operator); + self.write_expr(out, operand, indent, self.precedence(node)); + } else { + out.push_str(self.raw_trimmed(node)); + } + } + + fn write_comparison_constraint(&mut self, out: &mut String, node: Node<'a>, indent: usize) { + if let Some(value) = node.child_by_field_name("value") { + let operator = self.slice(node.start_byte(), value.start_byte()).trim(); + out.push_str(operator); + out.push(' '); + self.write_expr(out, value, indent, self.precedence(node)); + } else { + out.push_str(self.raw_trimmed(node)); + } + } + + fn write_binary_like(&mut self, out: &mut String, node: Node<'a>, indent: usize, prec: u8) { + let left = node + .child_by_field_name("left") + .or_else(|| node.child_by_field_name("base")); + let right = node + .child_by_field_name("right") + .or_else(|| node.child_by_field_name("fallback")); + let (Some(left), Some(right)) = (left, right) else { + out.push_str(self.raw_trimmed(node)); + return; + }; + self.write_expr(out, left, indent, prec); + out.push(' '); + if node.kind() == "default_expression" { + out.push_str("default"); + } else { + out.push_str(self.slice(left.end_byte(), right.start_byte()).trim()); + } + out.push(' '); + self.write_expr(out, right, indent, prec + 1); + } + + fn precedence(&self, node: Node<'a>) -> u8 { + match node.kind() { + "default_expression" => 1, + "binary_expression" => self.binary_precedence(node), + "unary_expression" | "comparison_constraint" => 17, + "call_expression" | "path_expression" => 19, + _ => 20, + } + } + + fn binary_precedence(&self, node: Node<'a>) -> u8 { + let Some(left) = node.child_by_field_name("left") else { + return 10; + }; + let Some(right) = node.child_by_field_name("right") else { + return 10; + }; + match self.slice(left.end_byte(), right.start_byte()).trim() { + "//" => 3, + "&" => 5, + "||" => 7, + "&&" => 9, + "==" | "!=" | ">" | ">=" | "<" | "<=" => 11, + "++" => 12, + "+" | "-" => 13, + "*" | "/" => 15, + _ => 10, + } + } + + fn raw_trimmed(&self, node: Node<'a>) -> &'a str { + self.slice(node.start_byte(), node.end_byte()).trim() + } + + fn slice(&self, start: usize, end: usize) -> &'a str { + &self.source[start..end] + } +} + +#[cfg(not(target_arch = "wasm32"))] +fn named_children<'a>(node: Node<'a>) -> Vec> { + let mut cursor: TreeCursor<'a> = node.walk(); + node.named_children(&mut cursor).collect() +} + +#[cfg(not(target_arch = "wasm32"))] +fn expression_contains_comment(node: Node<'_>) -> bool { + if node.kind() == "comment" { + return true; + } + named_children(node) + .into_iter() + .any(expression_contains_comment) +} + +#[cfg(not(target_arch = "wasm32"))] +fn is_inline_expr(node: Node<'_>) -> bool { + match node.kind() { + "literal" + | "identifier" + | "string" + | "integer" + | "float" + | "boolean" + | "regex_literal" + | "comparison_constraint" + | "import_expression" => true, + "path_expression" + | "call_expression" + | "unary_expression" + | "binary_expression" + | "default_expression" + | "parenthesized_expression" => { + !expression_contains_comment(node) + && named_children(node).into_iter().all(is_inline_expr) + } + "array" => { + !expression_contains_comment(node) + && named_children(node).into_iter().all(is_inline_expr) + } + _ => false, + } +} + +#[cfg(not(target_arch = "wasm32"))] +fn has_blank_line(text: &str) -> bool { + text.bytes().filter(|byte| *byte == b'\n').count() >= 2 +} + +#[cfg(not(target_arch = "wasm32"))] +fn write_indent(out: &mut String, indent: usize) { + for _ in 0..indent { + out.push(' '); + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn formats_fields_and_preserves_comments() { + let source = + "Server={\n# host\nhost=String default \"localhost\"; # trailing\n\nport=Int&>0;\n};"; + let formatted = format_source(source).unwrap(); + assert_eq!( + formatted, + "Server = {\n # host\n host = String default \"localhost\"; # trailing\n\n port = Int & > 0;\n};\n" + ); + } + + #[test] + fn formats_arrays_and_match_comments() { + let source = "result=match x{# c\n_: [1,{a=2;}];};"; + let formatted = format_source(source).unwrap(); + assert_eq!( + formatted, + "result = match x {\n # c\n _: [\n 1,\n {\n a = 2;\n },\n ];\n};\n" + ); + } + + #[test] + fn wasm_export_returns_json() { + let output = format_source_json("value={a=1;};"); + assert!(output.contains("\"ok\":true")); + assert!(output.contains("value = {\\n a = 1;\\n};\\n")); + } +} diff --git a/doc/manual/souce/components.md b/doc/manual/souce/components.md index 83f50b3..92493c8 100644 --- a/doc/manual/souce/components.md +++ b/doc/manual/souce/components.md @@ -39,6 +39,24 @@ The JSR package is `@hare/decodal-wasm`. The generated files in `packages/decodal-wasm/` are committed so the site can build without requiring every consumer to run `wasm-pack` first. The WebAssembly package is for execution, not syntax highlighting. +## Language tools + +Source-level tooling lives in the Rust language tools crate and its generated JavaScript/WebAssembly package. +This component is responsible for operations that must preserve source text details such as comments and whitespace. + +Important paths: + +```text +crates/decodal-language-tools/ +packages/decodal-language-tools/ +``` + +The npm package is `decodal-language-tools`. +The JSR package is `@hare/decodal-language-tools`. + +The current language tools package exposes the formatter. +Future LSP functionality should build on the same source-level tooling layer rather than on the runtime core. + ## Web editor components The Web playground editor uses CodeMirror 6 with a generated Lezer parser. @@ -94,6 +112,7 @@ Consumers that need syntax information should use the component that matches the - Rust execution and embedding: `decodal` - Browser execution: `decodal-wasm` +- Source formatting and future LSP tooling: `decodal-language-tools` - Web editor syntax: Lezer / CodeMirror - General editor syntax: Tree-sitter diff --git a/doc/manual/souce/development.md b/doc/manual/souce/development.md index 514920a..1e92c0a 100644 --- a/doc/manual/souce/development.md +++ b/doc/manual/souce/development.md @@ -24,8 +24,8 @@ cargo run -q -p decodal-cli --features regex -- examples/regex/main.dcdl The primary crates.io package is `decodal`, which contains the embeddable library. `decodal-derive` provides optional derive macros for Rust struct integration and is published only when the derive crate changes. -Workspace support crates such as `decodal-cli` and the Rust source crate `decodal-wasm` are not published to crates.io. -The generated WebAssembly package under `packages/decodal-wasm/` is published to npm and JSR. +Workspace support crates such as `decodal-cli`, the Rust source crate `decodal-wasm`, and `decodal-language-tools` are not published to crates.io. +The generated WebAssembly packages under `packages/decodal-wasm/` and `packages/decodal-language-tools/` are published to npm and JSR. The project is dual licensed as `MIT OR Apache-2.0`. ```sh @@ -58,7 +58,7 @@ site/decodal-site/ ``` The site imports Markdown files from `doc/manual/souce/` and renders them as mdBook-style pages. -The playground loads `decodal-wasm` and evaluates DCDL entirely in the browser. +The playground loads `decodal-wasm` for evaluation and `decodal-language-tools` for source formatting. Important files: @@ -74,25 +74,25 @@ packages/decodal-codemirror/src/decodal.js packages/decodal-codemirror/src/decodal-parser.js packages/decodal-wasm/decodal_wasm.js packages/decodal-wasm/decodal_wasm_bg.wasm +packages/decodal-language-tools/decodal_language_tools.js +packages/decodal-language-tools/decodal_language_tools_bg.wasm crates/decodal-wasm/src/lib.rs +crates/decodal-language-tools/src/lib.rs ``` -Build the WebAssembly package before building the site: +Build the WebAssembly packages before building the site: ```sh cd site/decodal-site npm install -npm run build:wasm +npm run build:packages npm run build ``` -`npm run build:wasm` writes generated files into: +`npm run build:wasm` writes generated runtime files into `packages/decodal-wasm/`. +`npm run build:tools` writes generated language tools files into `packages/decodal-language-tools/`. -```text -packages/decodal-wasm/ -``` - -These generated files are committed so the site can be built without requiring every consumer to regenerate the wasm package first. +These generated files are committed so the site can be built without requiring every consumer to regenerate the wasm packages first. Publish the generated WebAssembly package from its package directory: @@ -113,6 +113,24 @@ The npm package name is `decodal-wasm`. The JSR package name is `@hare/decodal-wasm`. JSR currently expects a single SPDX license identifier in `jsr.json`; the WebAssembly package metadata uses `MIT` while the Rust workspace remains dual licensed as `MIT OR Apache-2.0`. +Publish the generated language tools package from its package directory: + +```sh +cd packages/decodal-language-tools +npm publish +npx jsr publish +``` + +Run dry-runs first when preparing a release: + +```sh +npm pack --dry-run +npx jsr publish --dry-run +``` + +The npm package name is `decodal-language-tools`. +The JSR package name is `@hare/decodal-language-tools`. + The playground editor uses the `decodal-codemirror` package with the generated Lezer parser in `packages/decodal-codemirror/src/decodal-parser.js`. The canonical grammar is documented in `doc/manual/souce/language/grammar.md`; regenerate the Lezer parser when that grammar or `editors/lezer-decodal/decodal.grammar` changes. diff --git a/packages/decodal-language-tools/.gitignore b/packages/decodal-language-tools/.gitignore new file mode 100644 index 0000000..4b2f020 --- /dev/null +++ b/packages/decodal-language-tools/.gitignore @@ -0,0 +1 @@ +# wasm-pack output is committed for the browser language tools package. diff --git a/packages/decodal-language-tools/README.md b/packages/decodal-language-tools/README.md new file mode 100644 index 0000000..edb0e34 --- /dev/null +++ b/packages/decodal-language-tools/README.md @@ -0,0 +1,39 @@ +# decodal-language-tools + +Source-level language tooling for Decodal. + +This package is generated from the Rust crate in `crates/decodal-language-tools` with `wasm-pack`. +It currently exposes a comment-preserving formatter that is shared by the official playground and future editor/LSP tooling. + +Use `decodal-codemirror` separately when you need CodeMirror 6 language support. +Use `decodal-wasm` separately when you need to evaluate Decodal in a browser. + +## Install + +```sh +npm install decodal-language-tools +``` + +JSR: + +```sh +deno add jsr:@hare/decodal-language-tools +``` + +## Usage + +```js +import init, { formatSource } from 'decodal-language-tools'; + +await init(); + +const result = JSON.parse(formatSource('Server={# host\nhost=String default "localhost";};')); + +if (result.ok) { + console.log(result.source); +} else { + console.error(result.error); +} +``` + +The exported functions return JSON strings so callers can handle diagnostics without depending on Rust data structures. diff --git a/packages/decodal-language-tools/decodal_language_tools.d.ts b/packages/decodal-language-tools/decodal_language_tools.d.ts new file mode 100644 index 0000000..a9c99e0 --- /dev/null +++ b/packages/decodal-language-tools/decodal_language_tools.d.ts @@ -0,0 +1,38 @@ +/* tslint:disable */ +/* eslint-disable */ + +export function formatSource(source: string): string; + +export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module; + +export interface InitOutput { + readonly memory: WebAssembly.Memory; + readonly formatSource: (a: number, b: number) => [number, number]; + readonly __wbindgen_externrefs: WebAssembly.Table; + readonly __wbindgen_malloc: (a: number, b: number) => number; + readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number; + readonly __wbindgen_free: (a: number, b: number, c: number) => void; + readonly __wbindgen_start: () => void; +} + +export type SyncInitInput = BufferSource | WebAssembly.Module; + +/** + * Instantiates the given `module`, which can either be bytes or + * a precompiled `WebAssembly.Module`. + * + * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated. + * + * @returns {InitOutput} + */ +export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput; + +/** + * If `module_or_path` is {RequestInfo} or {URL}, makes a request and + * for everything else, calls `WebAssembly.instantiate` directly. + * + * @param {{ module_or_path: InitInput | Promise }} module_or_path - Passing `InitInput` directly is deprecated. + * + * @returns {Promise} + */ +export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise } | InitInput | Promise): Promise; diff --git a/packages/decodal-language-tools/decodal_language_tools.js b/packages/decodal-language-tools/decodal_language_tools.js new file mode 100644 index 0000000..47a21f1 --- /dev/null +++ b/packages/decodal-language-tools/decodal_language_tools.js @@ -0,0 +1,209 @@ +/* @ts-self-types="./decodal_language_tools.d.ts" */ + +/** + * @param {string} source + * @returns {string} + */ +export function formatSource(source) { + let deferred2_0; + let deferred2_1; + try { + const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.formatSource(ptr0, len0); + deferred2_0 = ret[0]; + deferred2_1 = ret[1]; + return getStringFromWasm0(ret[0], ret[1]); + } finally { + wasm.__wbindgen_free(deferred2_0, deferred2_1, 1); + } +} +function __wbg_get_imports() { + const import0 = { + __proto__: null, + __wbindgen_init_externref_table: function() { + const table = wasm.__wbindgen_externrefs; + const offset = table.grow(4); + table.set(0, undefined); + table.set(offset + 0, undefined); + table.set(offset + 1, null); + table.set(offset + 2, true); + table.set(offset + 3, false); + }, + }; + return { + __proto__: null, + "./decodal_language_tools_bg.js": import0, + }; +} + +function getStringFromWasm0(ptr, len) { + return decodeText(ptr >>> 0, len); +} + +let cachedUint8ArrayMemory0 = null; +function getUint8ArrayMemory0() { + if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { + cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8ArrayMemory0; +} + +function passStringToWasm0(arg, malloc, realloc) { + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length, 1) >>> 0; + getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len, 1) >>> 0; + + const mem = getUint8ArrayMemory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; + const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); + const ret = cachedTextEncoder.encodeInto(arg, view); + + offset += ret.written; + ptr = realloc(ptr, len, offset, 1) >>> 0; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); +cachedTextDecoder.decode(); +const MAX_SAFARI_DECODE_BYTES = 2146435072; +let numBytesDecoded = 0; +function decodeText(ptr, len) { + numBytesDecoded += len; + if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) { + cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + cachedTextDecoder.decode(); + numBytesDecoded = len; + } + return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); +} + +const cachedTextEncoder = new TextEncoder(); + +if (!('encodeInto' in cachedTextEncoder)) { + cachedTextEncoder.encodeInto = function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; + }; +} + +let WASM_VECTOR_LEN = 0; + +let wasmModule, wasmInstance, wasm; +function __wbg_finalize_init(instance, module) { + wasmInstance = instance; + wasm = instance.exports; + wasmModule = module; + cachedUint8ArrayMemory0 = null; + wasm.__wbindgen_start(); + return wasm; +} + +async function __wbg_load(module, imports) { + if (typeof Response === 'function' && module instanceof Response) { + if (typeof WebAssembly.instantiateStreaming === 'function') { + try { + return await WebAssembly.instantiateStreaming(module, imports); + } catch (e) { + const validResponse = module.ok && expectedResponseType(module.type); + + if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') { + console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e); + + } else { throw e; } + } + } + + const bytes = await module.arrayBuffer(); + return await WebAssembly.instantiate(bytes, imports); + } else { + const instance = await WebAssembly.instantiate(module, imports); + + if (instance instanceof WebAssembly.Instance) { + return { instance, module }; + } else { + return instance; + } + } + + function expectedResponseType(type) { + switch (type) { + case 'basic': case 'cors': case 'default': return true; + } + return false; + } +} + +function initSync(module) { + if (wasm !== undefined) return wasm; + + + if (module !== undefined) { + if (Object.getPrototypeOf(module) === Object.prototype) { + ({module} = module) + } else { + console.warn('using deprecated parameters for `initSync()`; pass a single object instead') + } + } + + const imports = __wbg_get_imports(); + if (!(module instanceof WebAssembly.Module)) { + module = new WebAssembly.Module(module); + } + const instance = new WebAssembly.Instance(module, imports); + return __wbg_finalize_init(instance, module); +} + +async function __wbg_init(module_or_path) { + if (wasm !== undefined) return wasm; + + + if (module_or_path !== undefined) { + if (Object.getPrototypeOf(module_or_path) === Object.prototype) { + ({module_or_path} = module_or_path) + } else { + console.warn('using deprecated parameters for the initialization function; pass a single object instead') + } + } + + if (module_or_path === undefined) { + module_or_path = new URL('decodal_language_tools_bg.wasm', import.meta.url); + } + const imports = __wbg_get_imports(); + + if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) { + module_or_path = fetch(module_or_path); + } + + const { instance, module } = await __wbg_load(await module_or_path, imports); + + return __wbg_finalize_init(instance, module); +} + +export { initSync, __wbg_init as default }; diff --git a/packages/decodal-language-tools/decodal_language_tools_bg.wasm b/packages/decodal-language-tools/decodal_language_tools_bg.wasm new file mode 100644 index 0000000000000000000000000000000000000000..a8446a411d8664470f3083bd995ed8bb80dee5ce GIT binary patch literal 133047 zcmeFa54>g7Rp)vB-2Z>xyY-hUs(^DZ74phJz@A7U!M64@{7cNFOkzG6#~whz#8(wU z6%`~OD^-tBV#N?eM1wZQQfZ-;bTf9k2Q{{(gAP5NbY~oN=x$WHC(*Q%X;EWK45sG$ zTWgVdO&_+V5Akodn4bIU zi*LN?JKufd4g0R!cf-x^c+U;*xaqos?|%2bTd(_$cf5M(*7L5r?t8xDyKlbn9XH*4 z-FM&o-3PC`>Gp#+9k}_xP2Y9h!5h9~-%Ux9|6=-R+G^#EL1SIs>NQ%r&KvDC%^G=U zn6}eayOFo@ZaW{%wOZ{wZ?&>4Yc$eEr`Jogs4JIj#0}wFeNt$w*B(0>;&2CA* z_G{mrEO%%kS=ZW{A4$XV@`BneL)`wjbjUcc?12efzH^saXwcyE>rzU$ow-gU#l zx4ip32fp*B)v_8%{T75=|G-tx(+nmdhmvuzY{dxbl_dzee(?m zZ@MwhD6jBXq43r;T~{lA*A4sjz56?p1M6#L2X6Ah@1d)zf$utS(@n_-(owC5E)N_` zlJ1++B&7XIK9nAQ=k6a%e=<&!=~!H+{p8r}w7s z{^9g^`n|Va{pMdt?@GTfeSi90fBz@aJJWZ3<4>m_On)@Jxp>QiY44}+Z$6s-?v45U zk?e4K==>x+lkT15JCbboOZ!`-3)z-QLqDBK^G!n<(siR~gyzAeNpm4f!p^IPNs&^L zE?t^!=@)tURI*ewM;8>$o!Q3m`hr@caVsR_=8FZQ$QQCbb32nX%NxyBduyk=wb$P| z*gD+mf6j})=kj~b_HAcxRqx-h65w5$Bt>52JF~a$O1{pa-#BS&5QD1)H?>CJ z-q-!8XorP;42s&x-`ka>MKh$A^Ln#bzbo6$PmA$U*ii>xzqB(+cJVajHI01Z;1YV@ znZJF!;S9T(X|>p}D<9GLGJkHrH0yAgsPk#_7t{Q!Xnx~MYJTI_Tl06EviVmFcduSz zvTXuaWAB19>=*2v=h(9Wti)bd*n4G(y=E9K6^(_&=4m?Civ-LkAfr>j^13sJB{(c| zr<}uIzZ~ zgV+K|8v}P>U}N8LBi}7vEE+%yBf}??PUwh{J7MS5!xS)i8jE73Nu8a$qmQPc823UE z($PoKNqd+E3P#_bCNLANnlJ#U$I>O3EExgVLiX`=+@@Ww9!n>Er*(CjJ5N2G8pmdl zW1mcS3a*D=AEDnF=3dAO zNPPWbaqOWR-@#i|?o$@D5A8Y5@Vbbq2qE2}Jhkeo` zaeO%(F}T3gRb4F)N|ek;#oUo%9vVNp4yIrZ_3_9iaUnvpj{Ql3%TSxCN zl((SwXV*e+iCXcyq4v}QxAT=kQ^(O{#-WMazRzIK|wsFs)N5Ysat4o;wv6L|LVWUYHM2ln!QbaPP z?=l5)GjZ-RW#05sDO09)ZPz7AWFIllhO39!49OaGrZd!uwCgjj=;UkfAa9a5~s=W-PFI6$^~68g44d zU%yip_-eQ&H8vo)Fl#4Y&ydVcZiejOQfd3TI)B)u?HQ2vMknpjOCxPw``ba<`3sXa z*3Oxc_6|sUN1e2HoRYL<052rJ_oGp&J8Az;Ny|>!pDb^kw12a_MdtsiU$0HtJB+k7 z=OXFzYm@CHeZITeHpga#bS5Ugx~|Y0X!C9Y}`bRISxbOb}5`LSXYkb0EhF`7F3i z1bf#^y}^CuFd1y5hN@St)y$1VUg>FDwen^frl|X6lun#J>a9?EZb>yYAFf_SagYsT zCNXTN42A^E%`qkOMpqBaS_?l~6N(=?l~CLO@ycCjjk|-beZbgYV1yjZWYR*-K}zws zDS>Fdei&3CmanK|v`H#G+We)S9VwDh8v6wl>-w(C1a_I*et}89ov9|Yg5_UyvGV3= zWn~mrQhOvy=zu%<3LP2o1-J7u={g>Nr7M~A%jeoG<`sFe!zoS!Jwt+gB}<_=;;VO8hbw)!E2)jmeTly zo`&#JaBCKC!_h-mLQf;~UYjOZDrInbgBv>~7gS{PRl>`LzcqOIfov8r>sKHq3Z1ot z#rY>5t6tW`n7D%Sdlsp`6kq3fa-)_Z)@cyx5370wVJO_nlN^j`(Ku;dAXS=27N zNn?xR5&N`Q=;OpZ^_ zp=Gil(m6)7xCU}B8s;^|Kmj7aJw^m!U-ShUJ{AK7kHk=Y59j!Vam2-Zj!dQK>Xw`Y9!hUJiH2THT_;J(d=gV6+ zjee%Q#WeZ}yN;1SwK*5gCuG$#A4=G?IRMT_Q{*7Ok3dMMHUw9ktX14%8Q{MV8 zf3LjtVg62e%P>Fb*K1pVuVlb&jYy`@i()!kX#BDkMd)|RRB)(t#Bm``sq zWNR*oJV<%yn4MlOjod@jr!$QdAqMW5T^-RPYZNu^qZhy%n zC=ESIU+JawQ6Vnt+0$EU98w z>o5jZ68Je4akI!^JiG}W-kJPnNv}@LC(2u==EurgYCgIaHJ=0Dlu_q%plFa<*D1`& zIX)*9lwjz;*a|MoL6JTZNm1y7)wATgSoSq_R|ZEA=5hp7JR2Ap$N1%$gap6SBZ4@R za&nL^iU>w|Uthle>DDUIoCKH$x+TcK=N3p8AFd%Eu7dzZG0Vy|qouy?T8lZq z*g)8st-E$#IAnm6BxWk(SwLHJ8o|JEbImi!1EgD%)dZItm`xO&(c-ff%vG6n3alDK z=7Sh!pl)8)9ahe~ErYhS;$gyvtH!u#4;7D}bo5#?G$co*DKrb*5AcN@%MGn1(iATy zK4WS^RUBO032DsvVx6Kn2D%R{LPO0MM#HgoTK9$i8TsQW0_v8P_V96B@m7(Alj;8P zy3$OQ%zE*E)k|d{nNXX|hufFtCR-Ez*{Z)=x2AUIMOJQ)G;Ej|;tKODbZ5|}tl;_Z zo~5~Sw^$BP=9xhG*2Y#6g*x3{e=wYzAFU%Jh&L{UvRM#`rc99eJxs&QieUzoJeCq6LsyL5EHPCB;5&J+ z%cw=c*Nc)*-Miapiw0z@JaMlrsfm_!d!oFJ#!7iBW5ur%f`=NhQC*_tx*bKb*f5@2 z9Pi3Hg)tiZ7RKVRj)H3A%3^^6CDKY`+4!pI@kuDqQcy;)PsLks4TE-nvX8xj*&?SD zABHRvpvF(u&4hmQbw!`{iKy|t%I(?mR&`ASFmNfVoQ)( z=SvF=)%kL`CSTI#3|}e(qtupR1i{Wjun_PZm%}l&*A?A2k|YK)m1{=2q9meZggZK= z%PRv9l*phXFcG=7=#6k8>ZD%h-zZv7Kpae&Ce_KTSduVSKU$ggvMtjxM2?q@sxom% z6t4+jO()mWSYJqk$z+i1nKx;OTy>oH6pNT+ikuX>y3LBYBE$Zfqw<^u^!f$$wkx$k zKXXN|n7eixx0Exp%%Bj{Ee6a6gfyHR#RS(%Z-HB>_EJ&;JhLe7ofXe9s_1b*iZN+ zxU;(9xtFEk7|X5WSia+zO%xv-tcG~-vNSxmy5auI((q_?!xrB9a{1$f>sL42eOVyh zxVqua%hK@X)eW1R`?687Wp%@?mj&XpS2x^zSsLEHx?y&meEAGAkY+7?2A7(wWX^=0 zWXuqScYU>n9$Hght)bUkCr)*iS$lir=~?{W?LK!*35C{UMr);+Cawig7&5*SCECin zAklWf4~Du7BCIfUYURRIF+A7hR8ZVoiu;*#X-Crk(${C5Bk5swmE7aIN_cV^R#%aY zt~Bcjt$x|mN8&ZyDjVr#`ZaHgPOaFKIK{5R^Rn3RN3pB%s@Otk6nCmdg!IdH<=4|( z`q9PWE^qduM|b7N6rfyK3V(Iy3AIY<*XV1q-NNqmlQjC~Hvf!ZN5{7zCg+<|{#(%+Ti z`pG%8QV?z~VbC207q6ACvq`}~vX=o#??e}XmUeqfx!zZ}5`eA{CE3+CivmbcUmBg` z!zFV%4%e-k(6Nz$$;*>Ncwo@P!RUyMc4hl$1$b`MPmvM8ekYA-W)+$UcPu}i2xpY( z^3v>jQNo%11yRe(A3w4*m!%0@1<*HQOY!qgTQdX4ikIJ5WJF^p>4|XU^<-q_6blL~ zPQy3uA7dnk^Y)Kh3@#0SkiG#csTEoWi^hSmG7apF+}>!YnAS30J7DiUo65Rp=`;)u zs=9}KZYg&u9Gs-K;+GC!xi(YoDHXEImnJQNm4!mUW}$oaP;4o(;2rsnqC*gJu!Ny8 z14Awt=y&}=knn5*Jnjbybu{xmOLOl@(Nw?E(W7xK*&wE3*-A!*- zUyYKv)rGZ^b?x~?Vv`lULqRKOx?ad`uL$PgIAg9eL$*!TJ{hG=#-EPfs;URaEt|<( ziWWRC>8S|=TN#+Zh6X(r$P#X#Hjy~AH2OM!H;bcRPOqJ`q0yi;Jsc0R?!d|Nhb4H{Y#a#&16?klprZ**{q#%gegWVMyk3*y7_kpp8EMnda0&o`xQ8T-^wQb7y< z=R|q{=vmLF*5Edb^-lR-2c)Fobm+!(Z$oE6W$HHI`iTOjWwE1+STg^|ysv ztS)QwX}}C8vH=DqN$lztxB<)wX^@&#u&z^E*b0Z2E~fMcNd007yNVm^D{SSnNsHB# z7Qod4(XyRnKC{>U+ zhs+3Ls?7*v=>a2_(^HyA@D|Axkof|ff@pv;M2`^}in_N7Z5h?-SnN((Li30=U)ggW zK9`{Rr+jJ>73Cufv+BKMP@*kLR7W{0h=uysM${P2Nu+2JUzOwvMzX{dwD)C*&=#D5 z@q{$>$-jdAuMBfHeMd>aEB;sIr4mN6LrzlfPUM+$ORQ*0xl!>CB<{Of#!T60ck|;)3KH%Q+sokz+HY; zR+vIsf5#{F)u)?OWUClhHq07mXub3aK0V9DPED~dg$sRdC40<$DW^4C<@20IZpoCa zrWGymH$SY`zLa6D^ciM`g~4K)BK%%5x=16GT#_Fs^+C$av{3o#f8+C7_e12Cp3%Ji z2c$3R6s?oJ2x@S&@si9O$e?t(K*H@rWG>BaFVQ6n=f6$NeDN!cncOUzwbZdNhBSVe zwXz#M9+8-wUS9Z|$y}L~)DdMxNXBj80zi0yd9MY>poZv`vT?>*n0lp(Z_Rk69`+L9 zt@cVS>?I4k40}cUx-{5N?UkmLSK5hzF9AXqYk8$LqdLZ@Gy>dFr7U5)%KJ1RR=J}u zF-&7Jzk}0Ug=#un5~}G=yTKr>A}%phV`eO&8dhCPSJq#se976Q61D@Q)Gkh`g9@t`+1%XISdO>*0z(R}M*^QP|H|Tv0nk|B$2g=pP6KrFh@r z57aupd+^x_5?aar@M}kw!dBc!MF}^&^x}*xz9j?7jH(Pv7PS)6iPA5(e-PT}c4au?5)#gdWKGoC>vURoK9Un$xPs^1)*a8;G1v zA2vvlvOCtW=K>W#Xq$Di$?Ugkrk!KJq@!*BiX^LVt6wYyLN256qqkM zwrv8Fxc8aFwn6+4QXS)^a57}72`scrRRkn$9^>nIUvUig0NT6+^Z5I}qMcbBH1KvTA zl1W*666IfFR|qI&KsCeHXsU8&1ZajM=&C(}9c{HGTc>HE{_k0ubi>(5E|FhgFU-O4 zBgmHhP$1=3BO*!3)c<4~^$Kzs)hJm;EJAS}-&i!(DTd=g(IamUN{PE^$TZ!k{Gg>V z>1Hfx^er~YJLo1=Qhtd}H6XG{+pu*^+0bRxY*QIaW6pgv-VlH<$6sNiL#C9CpTQH6 z`v;>9B=z>UHkzcL4?AahhOhqZw${(Do8GRz%C_cPd#j79l4N5_nrIwwj{%1vNMpOR zP8g^c&&A^NXN%`!@np7m6pKM`y^(dXxR@hWe`;W?tpQ3YN-dUS*$`0Cy~|ufMu}=G6sWWyQ{9 z$J+~+9YpHMcZP?J1xYkTV$&EI{o^5WA@Z*vv|4lUuoP)On3c(U{VK$x}!tMh~|Ky3>ogP`C5~94x9#r))9)z6HDQ{}_uaF`$0WN2Ux9ypycg_v$ z+qr?hyWNJ#+}IIukq8;$gJcM7%{Z%e_75k>wi>M_qP!nB+W*y$*#QouT`wtV_|N^k zHYR0f^8fg?AQt=}>uf^tU=L_9G<*DDo+AVhYoV(n8|IZ4@0gVKKNBqW92Eqohj5VP z)%U~6L`%}7ews(2wP6x|BP!{J2WHLbsF``P{gngH^qcHm16x-P+tqOYXm+^I)Q0<% zU27sWE1sI7X+lw277Hg9q^wc#yhd+OtWlLOZ$R7CTx}kwVRM`>hhWYyeD{YfOS?q) zUF9tZ|B^wV6)AC7$#CSpt}G&1T3df>Jm{3;Y(&OV6h>Mz!ITK=(TZrq*1>S{_@@0= za>IsF6BsM{;@}M{rt!@87Svg-BuG&N$^6c0+OGprjNy9h;6)pX<$$4M>^3|h7gT?l zgjCviXbhP03w&%)*6T(z#(Tpvp&E!lQ!^PAedoR58StI}74Lm@J7faL1ZVW3s$yQI zSrjJ{CR1_Jbw)s{j36mc1c}Qe;eU;`M(SEYZ>)JlNrT#&!eYP%G~X*p z-(5L*Y)EoPugl`1J9;WQ8yB%gw;Q3`c#Kznh#wN-t~X2=n`P0~L`D#zGB(tHfcox+ zUsYL7S(A-7ULW1uReH>Sewr24M(D(1^e(!rY$BJaXWtKHzp1j8HH$J3)oBgC8~(M* z+mxs5+VS#v{qzg=MP37~3{cc;^}@=QR)fHKV47|HkfU_QbjWcizR#p@yIB^J2R}Tc zryi(@&HMaXQW=h5BT;$s3zIb!qZ~GB5VG$G!EBAkiD=3JK$t;0y<$CD8P>6?sf7JN z3uNojF9Tbe)q_}RUKMRzTFGYMOn5Im%-~0Nr^)F^1s7#CsorIS+_-dPW^xiX7rfM}+=YLns}VN<28uw%l| zwAHVc3NmgYDsRzNkNUNg0Zx1xHpPuWt2qOf(13xb3yBz3OAZmoI+rjIo*LncQ#3ZX zqKC4I)1-`D2FQWSE092jBWD;y8_VY4_>YxyAgt8+$hoIKmsuFOD>2py-?}uHXK6-v zDqs_z^BR&>@=;IIED?N0VGN}o);WLo_Nu7An2gUt0cP68cUE!M;x~T(Vs9}Sy-oPv zqJKt{Efl^PZKocPH1vwpWY674nV#fZi!H@j@0*-eY1o3&O6CquDf`^IO*)<}%@Q=%j-%Mppp;WLI*4rJ9RFo(%|j-$wC zM}cm#QM^T?I21=gopKc9tMv&@s$aEVaFc?q8Hn9jN1{fE4;jS%W@ZpisTDg6YK!PmOwV*1G#-jaq+mO0C$gm4uk#4Fr+#J&~lUH+oth`9eY~%!s9nlmGN#I{>(} z=Kg(6Ed91!ix<~6C)bZ5I0TRFx>M$PQJ^w($_jg#wHt|NQZ8s^kyFm;2?*T|$2L zM2&PkV@mX68PDCoiDQU52x!u@I1ml)m~@$8b+W(j3J5Ct5X(+mqFp!&ufA79sbr1R0 z`t1UFV=okHJ!_aumaAh(=y*QKr9HWPI9DPm$l@B3ZlR`gX!ziytzZbWQ?!Bo{v6X( zJOpG6pXo1enW@g0;nSUj1A0efVkZ~s2Wn<|B5oK3-!sW+6;O`nl6MBf19^$a2Yh)B zaB{QwzK_-l8`pDJWRJx6-n9Ot~DQ^}(GhJO6C}QE>_xgmp>^TMjf9`AmbY9y2?J61aiFa* zD&Z&k2G%(1(5*2auPmW(XN4c^IxGA-Q{mTf;U_>#;RmSN5EbWJ@|?a(0myvR1)!GR z>jDtYsR=;MpCANHLNY^+0+0roL2)`bk|wum2tXce)C0tm9%u=X_qR9`fWTE8S@NUE z&qOOJb>Zj>UBRJ>ptqGk9pn4W8KHR^n};_M67$l zOP}z%PsX}Wcm{vH0{J{dN_$Kv1Wg>7`1KNa(@{ z(mHRau_du?X<(R2e^A1l@&$AM;mc)ud@PsO!^AS(P0w6H3s4UUC&7w&H0dqL_T>^0 z8dDeO%2XEIDe)z7O<%G}__?j<6K9LuEgn^SI)s`pcL@e^z7%UuU8uOyNlC}y=w}U3IfxhK-n0)44WJ`f8VK!pYf zBb`cRaO%)>#HK&YUjatRU1pRvxO|w)Mh1W)jSh~KZ=q5T9T8+_^lBy|cWYZ?r=DyB zJ$8_>J0rAQm1d%>Q2@r>R!bNkSYe=(p_tUCXiDbg>lBt&HCP_!@(>I{x756yR+tx! zCh}<>ra}E4$AAa5t}3~*ITlXc6M)2A9I1cPk!WGwh0r44dPj_EkG&nN9|wXVV3I{l zN9ZH7wuEu0lo=DCj1Q&9zHQKi`DT8}3~AA=krp#ZU0!qUl}U&}8XtN?E*63KLgv=$5`hm4G8G{6^DC>vs)!7C)%-;@oBWO*IsoG%Q z(s*db3!zAPcO4CkZ=FT9pdj1Lbocj8=6H8v>o^2o)DCa?Y7T4AGcVPe zo8v%=$xx;V+{*P5zkT~1`X0S_I~ht^;7pYfKTa)+u|I2E6cz84lbSBQ7EEa9oX~9R z`o>#Y2fLrDO7Ec49KfJ)bn~z<)B(bgTS11s+zo>_u}mPi7z|VaopAS?+IrTt=1}!ltwO~5XemMvY z4}r`;HIEaPl&XRDsyZ)aphFS$m`DqYYeNQ&In3(4f#BpypVlkM^!p*?zA4&@V1><9 z1WPTPwrb|=6lfMq9nKYRAWcf*w<$D3nv@8QcS59<){E5NEK4nJR3la#iAbES@<31W zJ8iyws&k~MJsF7={YiDuj6d13G~uHg_D*$@p+QoS^CsDB_b^zu0+Z*$TX|1w914p6v0IU>W0~w5NfSkk9jL~V77o-d z8K&z^(hP~8ZX0he=EfVPr%5gzC`?BJ=f&wgc@@CROll2GYS9Ac$&5E4mN?@M2at)^ z`J7OBrYT1tkv|Qg>6kl$8%&yhTw=A0fqdmov0d@mPC>97KZ}Z*Db|xCQ(3TY{gkH^ zz9`mLOy?qv?;)aDMIpwrh*5P*qmgUZ>}1>lKb(vc$zRFT5@{r4IDNc8&r~d7%n6#f z$D1Ls6i2f#iXcU-DWXzzyiJ6cag{n#F>3`xxr7(6MYv=DNH!Re21ZD1HMaKv=7)9z zF{ueTc6>Dfn;B_uQn8ImWszk=w0#uEBNQAadhL*~5giuUQh2azB*Z9gY=`B{*v{=1 zi$$LsdD6x7(V^;5hS07*5=eR_Us2A?0hQ1oiw~-1DFZ#GK#R!JR9luRDl55&(HBmL zq>zt_e?ytmBF-ALKb$2cuA$lgtD~CajOS<3K_Y4@6)!K5Xf1C%~L+ zuB$Af2*yqrvk=pp-&h|-LvlGMoCW)4f zdP(9>q6J9eOOV@XdZuD2S~h9=ENtE}(XxqAXbOQ;VplRG_cjrBMm_4R5-nhkiIQ-U zV=MCW;ka<|c4LbYE~zBHFpc20$;YC!$rtw`zDW9#OvSVhiuMvV^nK z;;d3Pf;r@ragp?RRF&k1y4t;JD0$=hR${iUZ_}y`*SDSWUX8G_U10HSz~Vt%LX}aM zYTZ*Bn6oD2vjC4Z@^kOGGQ8mE= z;IyV%9E8u6Ek39h7s4lWuNR9%Ubz;%SXsq|(#oo~Y=~!!Z#ZC=O;!5G!?!ZSb6KaQ z#3ghrLBL$1wc1hg@@sROGo!L3nH@bb(Sfs%=z!?dp+$%ZEEKrfX?XI7fbNoTw1h4^ zPQmB_!3pwq<%HYXTJ$9-2dx-svyaV|a}%B*6&?@_FhYy9+-NQ6%c|VJro1NvVvyi6 z7$iRCDF%cO+|C+G?-M)*#Y$``a3TBYxNYM3?e$sP4>3FuH}QZt7Nrofc%6+Br_*1! z2D{Go-jDzR!IIrFeVXkql8cgLu0{4@mN)1q)0v2>7ygTK2OFa+kkYBL*e=u8V5uO3 zkFyIQH?S~z&$v3ngqE=QYAt+5Ei^}0$OoRb`^T|eY1wJRy|o&)1OtPIa~LzT8;OTA zVEr=~T{hE#wCpO-JTXB*bPf=_6j+I!=v~&wGxj&}4Ez=|aQc*Ix(dEBYFj?309&EbN7ncd+GF z6R5?DktP|`F#7KxkyhjjrK6FtxR~h>_$)kr{|V&X!01Lyj2AKeyPAnh(q75LM%vXycQ1)jBmji|xV zMh$B=I2f9plf2t;=_-&SJ5z*5p*U>C&a!xo!vBAU{;Dvvj_`$vdH{A_{<_JyL>^j6SAYTWwZIf*qvqQ)tOtG;A~U<(<=-Oz!@N*jzCfPSCTHN^Lx?0C>co=7^$Y=-}1VYSEN&Y zwU6pD3HTu_0*=+p1Zqop2W^T$#Oi>(U^-o5%LLP;yDMKPx(~TXj_uFz0U}Od)1vaR z(Ua2bkt?R0MTF7f$g=Xd6oW~~NBBX1GM6Q(o&l%>#+4R=>_{})OfO1Uj8HJjt7!bV ziq!CYSoyzhEn*g~!+7HvWh|ixGnDDh&jseN!T5bNrDo|n+#z*IeM0GVMbiJ(5jIs< z8>62kn68b{X}Cx`1e0H#bQe$hpZ1-E1Tgv+zwy{Z=HmKj=(oH0nq!M6=kJ{K7n3*B zdvA|0org}vepIg}Y9y#WuRP80PYG=Ou zPj*j+p8FnH^;WClU$MkhJ=HU&rnPu@%q;HApGw)m%qk}Pvs9T|OcsCQpZ(z{ew_cemO1uMq>Hy5=Bqz*hZe86i!K|-j!s6z1&HVE6}ZPH zLp4Xyp~8ZDg8wtd9r) zwVFb~Er*2u#ee+2-2Kom{MmoK`y)rX=QRTC~HFfoi>a)@|q-%)bep<=L@zU`w&A&B(ON%wt=3(Met;jr*^jo05(tN-?C zePI7KW9X61(yCDa>FN>e%sYgEX?t{tpj_91*m8)n?qYTflrTl?pg**j-Zh!~Huy1x z{NTAE8xahFB32>u&Z7TqOh7+;{C&s) zvB#ZX`nli#kL%t>4=O_3=-^U&);kRUEH59m3UBenZop7Xi}a3yy+(@}lXr+!vlhEU zoPdAyKm1v`FN|(m3hdH^VkUjycM>=1ZdUX=8N|87H7ZmE>YhH;_)GG?N3^?`9WA^q z`n4?~ws69WV1aw^0XC0CCb);!M*D1JqKLI5E^kJ(T(YFCzPX%hR=BHa{?-YB3_di58dS}F zdp`=L{mP&Ii`N`pTsXG)?Eif7>7-8{e=kHv6;A9>j{84gvv3G3o zhn7FS{Olbk+IKGg*EBx4OcG=HOZlCP3wIsWat@;j~)ezN1r)y$DMcGeg7qgb|s`x2X>B=;|F;f_4jS$hu=5pYKs=z zpH>Z}3)OqPezlX+w#cl(N;D_w*gK9Q4ArNIy+gTzv^gsagZz9dc4L_LiE- z)C_Em`YYRtQE5W=RaF|%l$oDMi~-+00z=>47#r@`bod65CW8v+y=Ri&TI5=s>Aqe7 z<>8A9`@)9XAaEya9X>_r|DD+5R(S02K5kPy&=X%oXIz|`(r$*&{B9CH^Y0yJ+oZ?s zGm@~6PR5q`koJF;ByA7Le9A*IrJ|_+%8uDWFp(d=pcsRqGFb3{(3;m+(D*5?7k03Kme zvdEbQzVKn-mBY1FY>m*?DTXw$6Ax<1xwQmaYg7LroG z3g3wCSQ0@W5bck#aB$D(sx`~|H4{8D5&_Q|w3I#n$4)j{nN9@ae>G_il#y>pMyW=B zp_%?%EWj5c`P&tr(*$OhRNq+>#cK|0pINh_*{`fwQI#lRh!d)mTd&xhF)8U2kx6sZ zDgs6HC@)ZZhBR$q=T!{LnnD>e6d#!AoE7_>`fT8W!q;){K9j6IAh!j5GB77r9Fm3P zfqQKmwN`&ZvNO5QKLkjZJCnO>9|cr!TrDSYdt&)fz>PL?K~Ce^@};lDfkTe>R>Xcu z5*x%Fg_jqe$( zXi_r4Rsev`WJ1uf^MOyL7rwR=1wjYFE@W$q1dpOK+x@sB(I>uZ^ZyU$(v~)nEmxmD8YmEu zjc`##5tw?S2)YtQG+mLb{jaK!P$8)dwO-1hVfM3KB%dMi$eYR#x7_$P^ix*yfW)8t zE}tY?)1d~kj^RaSR8aP|(q&&Pa99w7Mi&*w3hbFJ2owwCbewDX0zcAn>HmguZ| z)hESd^jc9i;9fZ4_;VYgf)r(tfd`kE?Zd@u?1L?^G7FBGrqcgX`;dI?xu!Rcj`2oe z3=2S{)No->LYa2jNm$oE%1&89{sO30c!WyA)!Yedi8L7zvGI%+eSu9`{d6f>DuPT)8D z1YYA4_&T4!uPDx0i4bkS#!dLni{c5K=OC@Dl^nznKM{!&T^iLT z3;a7XQoMu!G>H&^r~=hyGjm>M5}4Nnn7wf@-zW*T zfR!3C`^{e!%)ZVjmdI&^*(f~ifeFuRcveo4VaEmxuvnNrh*kKPi~|3{=Be<{6qWcF z)kgeRBr8eZ(r#eQ=xOjDCBB?eWH3IcfhypZ<*0G&%_*_{hy5&{dT>p=IxHjE(tH^V zgT+;W*b#N4tm(gITdeB{pkf27GDI#+bW+Oe5vj6-{f=`}&?tN*yQLMN7PYw2b~Y^h zvOX%Jyp)Z32op2BPo_V%XG=4Hkt7qSS%5#wm_oMO16x2PN8g|DgDw~a79r3tscqzK zhhrc8by+~{<+X|!Q+(lE740Cta$qKFSQo)ulGxB0QkVsA0O<%Z+&-mXnF(7#O<_#k zV!TzUthuP}fWB=D!{q*z<3nPJfJlhd_zG81%+rPX0^&p=jg3qC1mb0YsJnsPUBcBx z_KidgIxAUVE8GcrS16*!Xg^K8m^M1Gjo*L4Hg?az0aOl$LF%mln?YK_^?fVbl=-Sp z%R@#51cYk0a7^3`DP62ICVp5+(PWp{1&1&?Fz`u^H6M zlLTx-keu1WtyXC)q0yFgiKdPfxZ}e{${B2j>ukc~x4`V^EBhW1OThk#L3!gGkgSz{ zxexl1(M&D>YEeG@YLUM2L!@6e;p!>5W(J)gH@rGd>-KWm!^N>=$0?`&gLj;mnfe5x z0tXO+o%DpW1?h@lO=48EN8uR|ti?{?f$FuC);%B-Nfy_{2B=9zL=^N5qohI<=9GSB zrqnzcXAq_|!*8Gp;Au+vi3d$hd$d!eXc7na@BWmQocQ#LDQ%RAP_|H6&g^P}I<=fA zTVBEAKiN;aa)OGPlQe{AW(BIZJSftjnuru_wJ{Gc{P{mbF?${qyvO3J);(eA0*@Y7 zpCB6kKM4go9m?JicX@+Y;@(gm{#dP4xlpv7hd+r8OVm$Wmb_invQ7_>)sd1Sl4!${ zg9i;MuR#BJHq^8k8d=>85+I{l`9iv4bx ziO!)CE>@M_WY12Q`@?(F{3h^UdAy#gB-bdnK6!?s_5622q%=%gC2Q#jepDH;Q&+=! zjqM8PVp`_kGT*6a$r`~HQNA?KGz$CvPp^;|n@xFYk@CbU8C5!5*+~Z-#;eu;Ngk7( zIFmpsR417zXw%t?W(P)Xr_!;jvHIzTUNvR==NxfUasnu2O0=|niGBh0KD!u^^kTHH zS>^3d!I34v#A8W+0Cm7A)icE`+Wj2^lTy*J6*kRb3hqZ9cJ`KmU z;Ss?bbIXM5))d#Y-DKXZv}_V+RwkB-sEnlI(Jp6%X{LKG`z{UB$~Sw_$gbs>2_)gT z8Bq%nH6ywqAW0J!JYSgMs4X>4+)_)wOgvyJX@xjIIn`zgSyG9yRWk(#0EiOAeWsdm zri_!O@0EPb(5KP`5?C!=NN9Z?kX?GO@f^BdT`Eylcpk<-@0ANF_pk>y-;vN|BikK5 z;A=@16yZjTNk&K*r*Nr?wG?Jo@Tyiq`SM07T~_{z2*DJVQU`%Q>4r-r-*kW~OCCyU z;V?inGZn@%)Q{YXxiu!UxICu~+v;Rfb`zLpF&B>>U@!vPYDR`VtjLR6u~PeknTGYP z8F8)Z>6~af*0H&2UZmC2PARPt5Qnq$;}}urQA0bjEU4O`c@9wJ{E(u%mz=FoJ{sE&GCf z4GwtQj3y0v(qqKo5+zNsB~nAQ^#HxW|2?Tk%J*xn_v8`yMO!_KmEiH|Lkw^RfGA(PyN)ded+lx{P`cf>Cj~U=;HDn?>~C%p5rH$ zkKC!0877^6Z|9T@+rlo=&?L>X^b77VO9httVNHY|opnm$=ODD-Xr{HWVK4K3cr_7$x6!0KF+Qh!Z(kPrI|bYxJbaqF;62Lc+=G}tK8y@fX0U33*E{|Flppi+2+ zD;)^l4;zFMc@Rb%a31uj(Yve*cbf!^!tUK*(Xn5^tQZrB&`Wl2oB_#cV)UQ*e3VJSDS%>AECN>|I$1{Q27jHLV4?N24!}TfY#?gS))W5YhBQA3vy(|!lF^e z8A6$lu`4MQPrNeBwLe;7&a5e36s0PWU8sj)eY{YjBqUR`SJ@ls(jz)rIYZ&d&Cd5C zl0Z7-AZ#N5q!++Bc;==hzJV`4qXV6UU7_Flu{}Iy>0z^x#4$ns3(v6OlqETa1Mrnn zZ(%d5$uY?iq47v?5dt00d*_e~D-b4n8!mbkyD~Cu_-H5O4^jZTzGc$bh7=z0@dz&F zp+F{EOJpFS4H5(`Nq@>coChd)l|}fuLpsm=${0h@y5%}MKU;;XFJ7}*=t=ZtAK77I} z=km#RO30=h_kgme6i0Q_onVp*<2{2ysb!s|uT7FevXZJ=mWKvS%~tGI6}xa4iJ9(t zv%IaDv6mTWjQ-IL1II)(Xc4J&75mXZyln#Tv;)I9A?X1v7mcfVGc_^Rw8VP9WVlbQ@2T)AA1{J4d1WY01!`CFaPhvWQiA=r((x%XiJ$ zCseVA4rq+cRfd@|VUawR|4ERICX7fYhh)ew_|oEC>KnAig{mU0WlwhC&kTtq(IIEb z(*zmbCNWUPu3Te&2^@X8QK83G80^tc93hU4CqvTai^3CFzf30gLbjV}HmqfYGS)yG z!w}-gT9OVjj3M*0@Qke>W5TV(*!A8j2A8I?>yT{}o(S~%D1|-R@Z=vwlepQLUoRxe zxz!=3Hi4LIhKAWxOK^xsgL>hA67dKnAgaoozBMq5H77LyAY^no{@dX!N)5U6H&GKd z7bt}4SOr$Cs&u$)cQ^-OL}o-Pi!q$zYvHsI6XW=9g=NBh!L#3VK2At>CZ8{Fn zK3Cpy{pmBvlRL-ruRm#7`jVPa5Edz*I1B&BjSQg+?`opkg*f&1oTT;keRl;#!^qN zSeA!KnXBm%%-076pG%Mw#DlnJK{Dctn^|)i(ptNL0Wof6qNc(!>AuFZ2p6%k;k|i= z3p3Ux_B|~@L$QTsD5JQV+l!J;EtbrxPPICtmo)@=ZE?NnHNIw%Y1g9$1S2JyoN~>^ zMsH!)L`0%TqLAtw9gH=ZEGp4^TH>(v9n7;8>o^LlPnu>n;_+fe$<938LPlKwnXcm$ z`8W~yCaDaTcC|WC5M97XRJXQ-BM%mWH6PITsuP7DE8x^D*KVS~19l6y;i`>&6^i?E z;U;yVs8Pu{%YCmpKXerLs@wGWUUj8|Fi2{e&#guE>4tpZI`w}1N!dVc9f34{Ad&3H zdhpenyj-ohii1*^E=B)gz+@sIW_GvQDrUMih1SCO>cN)?P}5)x8`*ci%420H3Ll7~ z6a^6BVA(_xF88jgXJh7a>b0S626odtaEx@3$*GL`Tolphr;qn3CS&4x_tIrA`xh3j?q+)cGzY$ z!c1tXFapikaP9YDMHTeyF}?r+1%#dYm^wO8=*$_l3qq(G$B1MVqP%1=(uc(@o>w~9B<6Du$YNRP*EC%kSQ!mLD`Y?5o8i)^$0{HEDFF5 z_WgE(3t^2Y5X!J!!+8k^$xi zQaNGJgwYJhEE}Rmq#(~Bh!t}d@-k*hT3S(IZT4;R^^5X77Oe=*$=Jupx-dzV=ctt| z(if`2EEX!*m)*wPl7mPXnbBxhhi7Gl6EYD`=xem(LV_B@qL$|;-S8|LbV~1HZkP&$ zFzt>M(H$D~*3iBU&Dy%{Kw$B&vmbXF(lc{(lEuf_^syeAt9Po0=0>miP>hEDgc`NL z1Z^@Xi`4q^YX%30lXpDd1_b|I3U@3wv~^ji$BqD>5~Z#1Jo*OCo46*9K+JLKv$^sCP%}29f+!peC&6T& zL8awvcQFSxXvMNI=he`7UMA9j#+8l9VuZ3W^$JlTUg6%7GW$x(93Al5Bi+PT4)D$# zOdl&-Zl+F@Rc@v=JyV$n>kp!!pH24jm={?qvOEF?w%iz%5{Fp?ann70fgP zXR(aLC$ZH~j}?jm%k2^fR*>m!RNIThDhdoL6%`^&^7&1<2z=)U5nVZs_Uv>Hl}ry?P}O^M7pE8?%EQh01}%`7M4&aY z{w)1~$K?4@O{Wub9ARUd?YpBfgjS>I(Jr|yY6A<|K9{hfW_VotGj-IT4IamdXg=@q z=>c~hd)$}qrK?C5ecip}lhT?~e!zmhLW<}BHYr9Og~q~yP%(8ctCee2IvqBu2KvH@ z=oE1V9L%WHv|Y>5WcuzlL|`53cr+*j^ji?9q694kPWQ_xX@7LN7#SFBtp_azEeK(8 zw~tlXR6U0l{du{;huM)E%E;PeM>YTr18ZrtQPC3sVh_D+N)Z^dVvQPqfCeZ^JZy+I z0ur_K%XROeaSDQ0Y( zfy|YxD|`GDtcwtitZSC~K*u_$2@E?!s+PSBi!e~pHqVHsl{E=N1A=Ao>V)hm>l!hR zMfuEX*T}8P-L+?@#j}V{xe&9g%VJ8&x=4?bb!m-BurwbJ^H6PV*6jih5rjJHuBf>N z>sl%WEbr!$l5di<4ltvudv(u6kcCFBdCN$RNg~+&k2H_xt~*#g=RvUlIzpyQQ(2G9pxon=4)rE6F|)5-?O4SIWhgPM%C~o5DZ&$^O;c zKBL?4%qM$SV?%%B+1}Or_fvY$!<=fe|5{xx-^1na@AKEdwy-|wFp&XXK&{N)Zu{Yp=R1wLwFyA0 zD~|4TtlpKuXPG?Sd-KBNr|${=RzmNx?X33)J#&3VuQdMbAS+00|oo+WW`JiER-lg>o2Q(dx5xW zm89DH61f!rvOuoa7FoVnHL%9()gp^z9GEiF209beB!GBCS(67eGPeN&C>5DAAk*+6 zMawyy62z26WdNN5gV&Giu@RbT=BndoB68KhYy}y3zjWWHC!8BukX;!*-Xnz(5PI)v z^>Fk9zRg_82Mgi1bl7Bf^mcR%4%!1!zQOEq-p}Bz(9IxNCh>_ z!o!MeY z+W%i$DOqwr2>cLH!5JTkQC{D6w+=-DcuVv53yc{j9zaz{tTHmG|hONEu$XsHbQ_M2pqSdBK zr$bA0T4f$!x*1&*z@;?<>h>3_bN^*z;8N5wUEB*IkrS9BFUIYzEv2|pa*t8%{i zXR@Iwr(4kn%?BHn2K&Z@0VH^H+9`0{iynd%BJHBsNO$fk|phNO{ed^|#y^_n0yco2Mx-$Xh=P%3!oM) zQqR)OF5wABTX+>xn`#w64gwlvC^t{-cvS+MjleN_Dju0TzR`>bogh?xu+DI1;#eBh zcbEzPd<_FU+Se>da8>*Iz{M0bUF8kXavcx>4FW1`2y-=rNO(#nLQ=+Yp{1Qlw85#o zcHBnwWsyH^W*rPO!;Oq4lN>E6y$)+$7kQZVRm|k$t`H}dsR+HL_6hp1={B|;u+7yP zuxI+51q7g|rxh|y9tzDz>kTK65<-?LZe?kSgLtA!%OwukK=I*#2t0RI0@_owAc5O~ zhf-N&6W7#k${?#fsV#A&7z#buZPJq|0Bwp4)YN!jtyT@9kt;?-@_G1!)R1b7;O63# zAUGl$kZr^r*@5Vcy|zvvOWQ_nk6B*L_s=!5B-Q4Ep~nb^IEVV0=xy3QL0+m{Lqv*M z8eRP`;An2heLzC!hitR}BT1{^d|`R8UyWrI;=&9@{<}RTGN_m`i3tZ`(H=BS1OzRq zNOC5;Vs`Zr8FEV!jomJ_N_s7A^YbSB!L_@{ffg!&LML+%iMda{cYk=4-;8x=XpQ#; z`=nup#LY$GmXB9D$BoWF)Wlp^!X&!Sp=1rZSSQ?aGvZ!h`b$B`D1BAS{R*u_F z+NEsdlcT4GdY_+|m869co2=UWaGYU%eySeKUsBf`XQ<=wO$$e`AZ71;W1JBgZgDK= zE}s!6fLv1w8=J7}|Dz`E0W2u9KMS8Y`Ms=c1$oTaq{J(O*0LQP**P65Gg^lfFz z1wILT`@y+-gACF4ymT!EdaXTrHE*a3s+k^PMzt~qU+q5-BzVwSIH40Y;9ofw0JI@a zDZez#JMGcM7IC7nRj*Uu<~-JqnV-kW$c?~&xe^RMC=L3My|B&xqBDhIMI+!_c944; z>VGxBXno+9e6oJbB8YHX?wO=5rt-tNP@!BbQG?;46Xu0_;bM(;`Bb&F%W3noIOu=_ zhz7yI*OPs0Yc&%wie3JQy0#vHgLmWr7|cwws9N)#u<^=0$xP&RDBNxcp5%}WA46nT zZAqlaNi8v-P1aB5AE={+(YgW~9&4`uM@<$qX#?;`Gm1>p7-ynfG1S_B&r~k6N$ZS7 zvN4mbt%>98xNLw>!i?6sqCh5M1F$BUjl;Wjv1|tvmtq+WrAU4$mZwXi{(cn8u*E8w zY=Mg@m$Qad6J@6t$R;exF^v9Jj3G+o`WRkraqOdRgIH#6D(9%NE^t{d3ojWu~wSJqmIazS(~iO(jvtVOyi%tnWl~MrvBT}O&be8 zwd@ykS!VGbu`BYWOdMg>!O4eD)s8*uw4?4vbaq*6j-8RV(vEhr>tpZ2kFCqlCbApY< z!1Q!ggkOU|PNzMhKk*dPfgKhR{+f!cYsm#_Tx^HI%Q#60y`mYuFWE&43} zRie{1rbVB&qL~+;wj#o#(^`*N5oDU7`Yexl`t09WKZb0}%0mmH?UX4y+KhD0!{!yZ z=4-NbTysS03S6IKC3ReHw~{)pk*T~@$MxCP6@@Q=>&+z2XcKo0*Fbm*TyLJ@`n(xj z_d^foj8P)I(Z1o1l*NVR)YGe`$a!4I(cW|!|L84hU!Dy4VV^cMXXncFe?XRrNZo~g zE~nyz_D$Bfg1U+$SgCxkIil3oCfbk}GdBxTw9tCiB|MgG?xk*ctmPN$A}ifX<#H+v z!b99kVjz~?X{#fJPG6aHDvwegbnT|*UZP~HCs<8V#8@Ha2S>F{UQO9v1N3{@1~qL} z8Y4u3H6l`S+^97DLrc)Ra%h#9fkR8zGOFC6C1YI?N8tjxLB&&U z9;_x_Nj#XG?nz1~+a&@cyH>c9LrGY4b(@~?BVepaE~MS%77920|Fe-cViqHxnTq38 z5CuyH`Ws>Y8Una36yit;dc$)3g{DJm$%biHp*MQPggw~U8+%85B3P$AI}(t%7I?P$ z)Zh%6+@#!ZN%qRVCIYKvi}^P&OyVKR)@>58sCs++u3t|AA#rtBoQCj8Qno(pA`Esu+f0D;KtMuthjm!h$x(FL@Z& z(WwyS`(RGr!3)jC3v?jCVo7>=|6exPNY^-Q0u;W}^ne=zA@fv?O{D%!J%coAJhu> z>%5*NvlJ9Xk`(MwgU-CgZ=t)~%lQEq2)t}JHmCSmVpBxME>9;!hZ~V!n!(OSSUgg6 z?^-mFJ5g2LAYdAQ#umzs4 z&W#EWm%zj3+PZH6E6#op=vO33!6&tf{+%F;4fpP=U`H%jz>h(C9;Qs6W5n9DP@^?P zhS-}7{59Sp0DtVEG5DZ&!Kcur?e&+(n`mY6n5~!~VX$t*vo2|bM$}ecD#^xW8C5(r z2US)i*Ft2>CF2XKTF>VdU=TjNqD&(O`rJo+miqTM^Tv_mw470cBsptzXQPeMafP`%a;8K$QR57KU*f9#cw;b z_`0`3UF~w;{OE1mG35P2eBz?BxcOUwr1Ow;$}fXH&gFOuV@2y8d{zF`U5iEUXUMIR zdq)$h$b<0QFOp6`jud_z zXcpeLG}lTw`9Du&aqUc!#XtD9lVAGlFaG79TzBWuf5jVYtzVIGk8;=R!F)L4Mx>~ z#<1ZgCSW%4cy$TP!+^`VeohU|u3B;&-qVHeTcH#jFLnkBSJ4%X1-dOE95vqZL2!gl zJ&5~1Hve{F87>jbF#kbJ+D?+4V!(eX1^E>wsuaMT4_6zNR^TIm02}cK7zXgvL8v1i zZ(cyep#~F@gO3T!fr((!Ku(^$G6Vsna328--PVahN^>;yIgJfBb%(E$y>zMNEq zO(z^Utiwe%#)%|z!fExNI*K)dW&}K2RkFad6$=yx6j8&SedpjHX;Ww7b%%64`t9v} zz{n06I9kfz!baH%i_eJ=Iz2(DH;^H z=)wkY2%CrhCl|ovLrVv0H3pQyDGC3#LLr29(qQs}cpJDXShR}za%_MSA-%%?cnq-l zS`1F|P<%xkjKH08JZZcK5PToSfw!LsAWz+)l{hge!iFNX?m(a@tN{W8Ba7d$(qs|M zgO0&XdO+r2c>zKLH9>h(2snYyL^w(RQU_@cO7)-|q+?J8y|W6GM|72lwE=O065%qu zF8Yp_8KWQ$*DYwOIs-}qOormXqYP3u9CoVb&|u25AC@X2Ze*Vz>WPS`VZGRSQUD#R z?U*+yTlSXyvLOYWQuS$2rabXGa5+~Z3~nS z8wgZ-L0^!6MFlJ{>y))VyuiaIVBdkM#Hds-{h=Jt_S5Jv>cW%|$CO~fhbdw9gD?;0 zf+V~Itjh#4C{Db?Ai)JlL&u8HpOR~Zq088dc>e1jO zw16a{E}EzI1Proa!1h2Pq69>d^_voicwdaqC2fHFf(XNnkkO-qxjS}HjL#E(gee8A zz33zCxIw9EN$(C14hkD!)}co7Cy+z_zXfTarT`h3oD^gL^(kxsj+p3}Srnrs##zS# z_t89%6!O696%SIszn(qeE**5OV7a;X6)V7OX}vIIV?30zu{Mii2Xt55V>|fucgd zHb4{6p&C^@8wLaLNQz$vjRCR=yD6}^0WU>2BR+xUzEc3Oy8+diLtA ztfJaSjn`LQL$hChE$sn7vQZWc$OuOxrb8GB4H2Ewh1Lv2n1!bysrWzo_ETYKMuQoC zdI|D+>Lv1(li3Un6*zzrMqi7N`o ziUM+?fV?Pxm!Odo2;m0d*?KyNXmz&@gYnkc{%1^S8t z>Y{*#D4;0{^b-a8ivn7rfVLd~{ez@<^>NQBAX5*q+SrR%L65-l5?yx;_o58mdeB1uV0 zeqRun0{o^RxIU4(GnNSdA$;{-c?$#ED*ewCiZ)n(Y#kd5&0N20m1>-**tm?G*L$DQ zv0&kn0h^m#B&fl^?KY77-xLgF8MYSGEyP_#XI5W$eBs&hSS%bgKtfRb9tuF?e^V|4 zNInDjGBPq^Hd4;G7654>;!kKNkbdFFu*gt=0HSk%V686#X_#oF$@Q}~G`JcYH}=T2 z@f9dy22>k*jF*-oQwEj@v2d^8`Yn{(o)b(43tYbfSHmOwHkhEqb0KsXZI+;Yuuj3C z(`|Mygj<4n46KK4bBN&tgp!H&JoH>(nZW}9i=X^hv||G1hY_tV0avn!c297dBb0(n zzBL^W zxH2$Q0EF+LcxBokjOgIrmiqgQmtMmSIw;6Mh(gQCBXLERL=T8!{&1)HABvQj3hA&A z+zmr<#K#+qIq)U8)S*o+XAhIkB!X!G41*ts>kW9+z+=+Dli>jmShvXN0cQ;EDPVTP zCv;Cicq{^aP{G0xG8oq`_Y}aMAS#RAfwc&_r+`Ev_Y{CeOyWZU+eOSGDMvwcWKGdM z1%uxoe(0WpNx7$hnkn}bxCus?2B9vLO9>_#{Ry!Q+DRNrFog~!2m=O{V7LFaLkSS< zfj9x!UScPJq8Knf!7eaBj05Tm;!uLw- zrFu#_448mxV^3%oJP3WG`VGt{%m*OD!WJX76#@tzlAH`Cb%i2qAcP_k93AREXsn2P z28%1AkjE1$=@RDG=0ay~p0`mZZF7x;jVN?)QNFgBrA&}hy=zwd-0D}aOce4YJ9u&ob zvdN|bDuVY=5&EVEo(igl4HKVWIxs`r(G=eg5&!@)%n>+(0ow?4Aqriy4ztXV)1{tuF&xI>(>Hf%GLyf=M zqoDj8+~~0=lK}>rra*oufovUN5~xdk)Pui!TL&3tUNn`B#9!0YLg7D#_AQ+(a?k%10aFiDdZ(Zuc2wA9wrXsHi^R1qmpS=>WYD52fqS!_Jy<(@N-{ zsQq1qq46Tseh`(2$^%MB1`#}|3h@~(EruF!6N;jHP688Dew~09uJdG)P{am$0W$_1 zHxo-bKotcfTnI0QG9us)nrM6tb3)|g2$>07C-Dko_y-m*23(&FP!I!pj&q+NIKIZx zz~?y-EmAs5R4}jtAgM)y!Na2<1U2Z;5vWH6W%a`Oir4@c3(Z1_7SI^t%N2J0xC~$n zFcQS2xXmUX!R$}Syii>O0)q_)r^X;1!$kl^G(fSC*&u@p*6WL)ZOn*BaEF%8L>>f@ z4o4Vr5}#2}1?B{}Vue66-~)7u%m(~`cKG-~h9fEzSdm3MF)VQllk=4U<}f@ukVg@T zNAifo7}^BOBamo1775_SGyn=njOWd8F!PA_Hl&0|9fjW8aI#U}+o04g3Q63V5hxJZ zIlvMKTbKJbLQkO-YH7j3(P9xvFR6!e+lEC0y@q_48|lBO0_*?<@Xm%o0N-RH)PC2d z&MXLPh;RoG00Bos4DX;?u(`u3i1A%lUw*6raU>I(h|fH%h<+(nyY!>Xaz7HtwYI!5e9&W=kqyu4wVz8&VVV7H-WssWi@s2c z)9=0@4f%bZzwzaVLU8o$5#*zRMkBcc*HjFCVLWVcaQ0A*>=DtI!QV+lfPf}U{s5F@ z0hwUIK?R^^Fq2?XqQnf)34~f`ra;FP8HxpuO@4^704&PqKWb@#ZK1)eg<<3`TTBV> z;2=64nkJ)zwr6EJ%LxQ^ch|E>gz-MWC8Uhqd?g0xWt7~$vN0P~kGFu;E! z&kw--F%JPI_2T!yOfTpJCMF}mY~l!a5KO+ozYdtm>;7lJ#3i+0s|YhCLpm`t``{me z$qMNNjPSDvn2f*q+gH`p`%>wvkd=pO^~ zC4)(a(``hNtWU03BqWt$=or@2e@N(Pcm)rxIt<|LkW#>b4^VJ2xLWEUOMnH`pF0$1 z1xn(z@q95*8j96|b6ChKpm+iB(#9%Dowbz5T8LTu(y-4qv8XIYj|{N$l^+92JSg0c zuS1DXI;;C_El@{iEo8>h20=YyB_crpOyzhGB$2YL@hjWy$xOegGL>@u5O|ZM~WO)%BLY5u% z;Dj4QIR!G)9L@y>W#a}CN!Su11pqTEd`R{M6o-uwp#T7|f7aasiWdN^pv9%KcO7zv zw?H8z|AsSba%T)kF_1?F<^^t}gzY32MESBr#|!*9xUQqMN?$rG!Dv!NTF3wS>P6x! z8EVJ*`J*>)qSB`eiw1Nc<-lOhfgL;9CUq4kI+qWK3nWSCv;22O;-n`>?pd5&39gT}cg{fERF!9WWWdqX~7Ngw2NGrS8$j1FN_>qwdD#@(Y%f zBI^r1W|BL!J97g6204XyU1N^l=U*QGYkriHA(!*dT%*C%tMBs0LBlD9W?l?yrZo%!9iI$j$q0tCa4*ki0s0d27?{@}dPCG!N1T;_ z%%~{6y~&zf(T2zfJ4&1~V8#Ndg(slFL4&9gG!KR(5@3IhJ4P}7{nuv}Gfiorvj?>* zTDafdY>jrx7-fM`Jc&w^!qE1PFHX7mfO8;dD-ZcWNB|las7s9B9fSegp}6mY`$$oy zhN2i@)v!AQH8%43*eY0#I-3MD0A6-N1ldy}Hv2E={tW1d=nEJfIyE&Zy2b!0KCmwE z6RMP8I)JPhw@z>c2Tl&502;+^KuBSuj*@ip1#ke#B!f@K#h<+5VJh7Bk_X^6UlSM( zu5fFtN#sF5x!{8~V=$~n==F=iz!yy7^$Q9FhkdXo0b~_9>|+8g|IzCg+B;n^a zp~F7d?~v1^&=6=AE8 zFX&)YgrNOr;8xs4=(<(|GPFqXi0FqYVzz;}fK)-~yoa3Y|HXL^3l>hWA|uXw@H^$W zt2;}QL1TfA3eByB{&ggPC;~>|8{(mvIPVchJ46r$;n_Zv2{F5z_dv-~eB!(ZkF6jv zMfnD9coBD~VuVE#zJS=w0KQPJd&sF!;#dOodqUSe@D6+;BM!qm6p&M{d*D(L;hiE( zp-_^LaEjPb`U2!`2&LP_0OgHvdNHh_J9wT1q^f+nkTJs-LYJ`EPCkf!G)jXz?B{xE?`Cp{^QP!f@P0zTEO4`bZF`yX&Jjy`Wh715Jey?Q)IV_rU>8y2VD8UmWQYWVc!O1 z9rPGz1Ua>Hol69_ak; ziS&QeRc1FtQA#^lDT+eM@_#}*sPU6_5Y5aemCH|BKMhJ_PMr?or2kQXfkgOUB)kv` zH~!bM3u>dp;z#&(@5iA3?oafVdZNgX#lHvA3Ru4Wq?lqEiYbs2Alv{R+9tYbPT5p0r}U~;Vt91OLHYr(b<7GmO+04yfpCSs}s489cF?yOu^Mpy#wAn=U`3_sXv zkyo(3a#duIg#va5e;}?WTpKEonUs?PREw*V%X+{X3#w*f)l8~tWamkG*bst1Q&cKA zH9&K)yl|TrtUQiR z?z|+WbBQGuaaP4?p;M+kA}cx^4IC1*-~bT7&K^{S*l=>NN$e+2oWfU~o;ZaV#UvM0 zAqhf`7YGk3WpQ^$9NU0DH`ujN=X24LfGPx-TM5{;Q(2)p*vpfSz#W>15|Vx(6(%Rc zXn3(PivC~}PzXQ=fw2XSRi|Kyl=HQ5IU zFO~#x6?X^B1B3~v3D9PUs!N!g#?J%uBkITr;5XKSGIq{gIweH{P~aQ@B1tZ;!6tyi zIAq*Kp5VwxV1wXz5IhK;A!a~I9y&R~W(zBWmXptD0|k8tgyg{}0ph}UvN~~RiC7ro z_X)@YwwZ}-1~U-}Vc95Hq$+?JLA=qC=J3QiBLGZsVFVD4EOUr4M0>#EJf%}Bs1UsY zkk~hP-~~+B7HZe{E1o03J0+oASouesBtn57aT3WKNDjH?e;+4FK7z!gsia z9st8}2P=9F)q&9o4ku7!c)$n)F494RjRDZ8Gx#7X=c58(vE*oFL=(8<9zOBt_z{MT z#T^f26IC{mi$VxiK_CJYPk~Xu8<;XUZvfA576~PZ|9>@j!vD1fPyF9D7ziB$v;lmy zxr8$_3~MZ?2+jsB0y}M9axNec(05A91czYNnG_udD;DZhv`GI%G7{HE=-8DWfC~sW zg-%Z4K#?Fy;o*@S2AXsdoY)56;G_$|PaJYwZ$T0RA+nx;Wj-EBB`0(!yuec+oc}iW zuY~SeWLRLdV48yzkI)XJ<_yFDCSnG%6zD_>S&mMJd0<#gJ`x&1?$!aV2NB$&McxnY zqq^>*fTG9(PV5dL1k=CEgA@~0B(TQ8QU(Vsv*D~#r@HFzvJ(owWhdZ%a4=cp|4nv+ zFay7`6AH*qphW#wcH%edJh8e@r~l}J17;Hwx`@jUus2#{O~j*^z^#&t!~l*6EI15} zmt`Sb@wzM~IHbWX0qDBmBM+0pb`Z-VnpVgJ$-q_<7HzO)AQTjiZQ=x_q>Vs&p(@Bl zB#XdUAk)oRM(?Egz=2?0s9*;A{1cG}x#T}0^2mW8Md!|dLeOlD__W3l@C2RI9HV{d zJer7_12aT%l)wz73K<62a+3`K)(H*a;wcb3j*Af?#!$r&*gz00OY+f1(`80*m!@d(9j=79t7J!BEiZYK?fbc2GjYa$PYsX!sbb; z!{z~WCm<8&Iv`g{QDu@+c>aKY|L*Cq#s82t0|p7r?XhB%MBotvihTfd6z(Tc zP=T^>_zc4ZEkjlt9hQ}ES1OdwgGNF|hg9i6ODq@w^PQXlb+PV612*TQCyeGILDfZ*hWHEkq_b*xb= zg+~8K3E)S#KS+fKfr5$f0mJYG_)L57@G6{CKp7}nLm@xMM^u5xJ0g*F!QCOh$hta- z15OkzKNPVEg=k#ae@56fomxVvO(3oWIOSmDhV<YiOB5Hft!{8$_)Gz&R8pph!ZD zKbU%hQ7(UZLMh~d*$UgDc{I+9PC^WH2$uu=2Z*9j6$op`kE%eT>O|5DBn?RySq|V> zJy6_Eir1-h`zMPQ>V^JaDSGNZ1c*pY^FM0wUsUY)A55tTOM|F^eksW^#uQpRAp;~r z2h^g14Fy3CF8>BvOCd7?Yzkn51GP3H?}+2eux4808jr^Z$hki_D?-P01)PH7qJ@4> zL|&387jb}A($YVH3MCISrxa63^OFl5YyNXOCqB^jCK zkecwnFuA#TP?ol^gV-}+L&@NDl4?M6oMW86Gz7p8`Wb#s5G06?y}Z0tF_cbdxno&;h{)FpiNhN44wg>W;3j z$t3*a*SH_PwtmNy97O~t&KELzJ76TZo8cc>5(oYo&QVeHRi40Im=Ip!SSUg&gft)q zfwmCQ6*^zzoWYkY8b^kd2nkWB$);)$&N1N7xjX3`AyVRo!&ZhP59#^fivu?Ut2dP* zzray|UL)SLCffjc1Uza zaCZ~DhojLPj<5?{PdGtE!rVf7Z>npQkc3KyUF9DGVkyig3yM65@iq8$@W91NhQ@!9 zc!tIw1h|VT!tRh1ND8D8!^TQcg~!NX2-?J*Pvc0FcSK_$OrHQplc@A;D%Ex<34+u_ zR6}^u`KyW`QBSTKDUM|`38pidI@-?l00p!C6rexKH%@v z{^yEQL{NyjP2dp9a}VQ{cH?3!5Y01pqvu)unPI2fm?Ti0^1} zA?|@b0v-imA#Bw}fTg~92ZfOF5MUpnFrTnFkdaG$L{R@vvULk~4+$0U1c(4bpqNqy z{;L-f9vbGUXJTQlZ)R#>DlqVNH#9NUH#0Q$@b+-`G%)ruvoJIDG7}iP8=0Hx>jn6F zgusC4xd#LUdFq9RcN4-5G4rtdkrCAAu0a1ZRzY&VEA0@sG)a2 z7(RXHx(B$13g-Qpes-1(-PD8f|4dn3V-^|~0&|>{H797UKo91cKu_1xJ;WzSF9c`< ze2*rhL=a4uf~~G^kdA?cv4y9%xu>aziHC`anYUh~d+1yp4@l-C2-MNnHPkgQG$AeWDAWo1vn6%)IK(~DHA3L|Q-LtUf`P6Cz$61wMB$zR zsaf=n^x{wAw{KXGyN-dbzOI2eDI4e?78@EA9^xq=w3J3;(7+5Cek}OG!b_fF@D%;g zAs`Mvcb=_pXmEggG|zW#aDZSg&`5Wro4gP~Sa?XFz>DV|NYQ6rc%UFE7^teiDoX^eH*6R$ zR1n}Tit6wTmWXj_Ga=s*Xt)$SMe$|`kNa(TK<9N~{m~wPrFjA6CJ|A-DH1dq_E!|Y z3V_h~AubOeHGf;~@7fuNxGZctH1>ybm{2aZH-g2bxx&*K+OPjZyaK{n@Pp=bj)x?K zF%Pz{4dB)np8k-p2Rua}CTtL_u-*W?d61?LeCq{2g&)&s4bbAbdjn15c>==mfK-O# z0ER*uQMo=)?$3FKiSl^+3Ie=%f$nn!ot0`W5Ph8M9_BfR7wQ=j9_AY;_#wrRpHl?8 zhapYvD#22V2ONUd!k?45hs^Cv0^Cwym@m{G()DU?a1gL`P}rQ#cMu2>goXkx4uJmr z_}7`FtN&ezyFLyZE^32!cpza0pn?$SE;Kl_E7`9N4)X8=BnQ9)bh=Uvrn=P$@XnI{ zki2P`d>6IYV(>?fyp^Xu>O)EyL zYqArr*Bz#Ph^QSt!ghGO2f!>Agb`c;@&QBWCGd6+4+#6I8d$sqQ42}pu#j*;V0b{l z0*WZ`!h(2_A<%wc^Me8ez>#`;3qoigVDqH{{ZxVFg$1|#(X z>H>^0Q1uXjCxX$E7Y_WYkYr9fx2LCAz!RQbBqzFGp2py2Xya5U<0Sk5M6__>pGR0= zxOa#s*7XEgBc%G@{muH{W&5}0(l;;dh|90z$R5ld z!h=?dU^x~5iLlhy*Ei5N)Hl*M);G~N)i={O*S9dxH!v_TG%zwSHZUrDS_)9V9KLJ4h?ZZD!>i<$) z`b!J{4;kd&F<=w!pFH(-e`LpenG^C`UcKtKU&{3JubYHVSQgtOWyj%Q+ z^Gce2O~*fOt?3tJd;RLO`Cn9vZ2h%E#l}RQ^NaVWYS?Vpz#j3%=h^t02s_Po`l~Xl z+$-xo^S7ukzd7}7G-JmH8QC*Y;gd)B-?E)*ypnI1p1(WFf0;ZxUiy|lziG|XQ;s!L zEBwA@CODsLD&4zAC?^}$e~_VWUX3D0)LFMoX8@$x>a zJC{G+y{JAbRkO(X)trtksWR3FubtYk>5gfD*_tf1vg1;cTn(M}j#S%`OAjy4HPn`7 z-z@m@rQ=|aO)s7XOtLaemA8a`oo(wZHtS2?zkGZ;^I&v1O!E#I_KY{%6eJ?6z{ zI2mZqnskFXJn53{%o*L*#MSiKbVn|sEOGsJcC_=WBafGRccd!q3dyrLHEv^|$Fp=D z>yA*Ds#LiPI(>(++f!myl4Iwz#ckqjJ!$OyA|_O_+m~`YT>-C`Gn9{I&TN`%^R?18?5?gwulb(+Mi`Vz zI<|jzl3ml5yxsX^OkLy@-nNZCy1-k_ zry=f3RYHs6^t@=5=e@08#%Vn{y5zd^9y6)S2C3ZS)%%V$9JnUYv}q~F>idBnyAR!e zk*k(?(U0a+RaNpRv#vq19s zgf6F<7rpiQ42~41#}t?EV`E%Km{@+f@g(PY|5a1kw(XtU+kt*=!PyM% z_TYW>$10SivbOM#WSErRtXQd{>C@^l<|6aDC%wGY_G|5$2^41M09?WJil^>k~t>9yH=)u8a(npyGy-r)*H=@bq!u4h=&r>tRIlE3C z%6Ie+pD*!NrhV?a^W&=CJXx<@Avb;Ws~aVCpSCo+8LgUi=R`rR&OEP%t;S~uTg2@< zSiL)KT=c3EpL6_=ks~wjXU02y&8%&1a8n-rW%uB^Wws%Qx1LQ@Y_agze6+^QrLd+- z{am=Vioy9IOZrtV4Xa(T#NTwCq36PrUh_V0yOEc;(SXU=(&4h_P06^!iIR?aU%$mO z;$uJF@z%-m$h+ioeZe=)a?eL0SKUr#56gcT7eBYp=jq!jN7_Wa>9)#I(LG!8MOgFF zQ+Fm$^_~>`YG(A66>4h(v~*Yde0pSPKktrz+!4onJ8!EL(>`oGz41zQVrI7X^~>F} zU&S>q-21IGKJUVn1LARVSJd4DT$G3H&%WNa*j17@EzUpMv$sJ-V@~;&eU@Tjruxq+ zzq*w~?q1zezGb<%tnJr(r!0>b_NY1ZuEkboR1c^2wTcYJuggLZpuyT zb=^Miaj{g^<>_wmVasX@wDR&i#~iYA1XU^1?$0$Rn{ltAI=UoAGx9j zXOG>@QTrzrXr@K16z|n|ch#L~Qkx%W-YT-ZsFYoOGp{x2*7G=a?XI!UPpYnBvTuCK zAFI~)%Gm1dvj+)+6D}u(-Bk1OrSZx~Mp#-^Tz_=)LPF?cKCR_W!vLx3$n#3<_Fb!; zC)4I}=d@fdb2`5Da&+~fMsMp?3QOjl-c+;hsaoM;eJATtx5vJ#(4$qF-_ugs5#u*; zM)%C3W0s}g#IL{Ga!F-rU9+s@og4@Kl4N^b+i#vZs&f?`QdjE^kLb~`#bMj`BtzEt zl<678S8nvyvVCyw+W@PjPu?|IYoAGeqQ7Cv=a`n17tocmHd+E1^ zomlenmZ5%%!jLocy=p^EC;L6iT4{B1|EA=3XEL-Z%U{^ue||K#hm70DwBx0%vxjgC z20Yv)dr$7zfs-$rk9-<+vq#uenOkd=ydS;kTjXUtbF{MThKv19RBiWPXWVd#cBk9^ zOYN3TzGX@F$82&NttU)!8P>-3XB`~i{6cQhK-rzU4oTmCQT9}(_vh4tkmA=%Up9|i zml=9*-Q$*nQ)PSwK7HR#KbAc4`mvtx9}jjcAAZJnj((_9NPOsojVs&bhn(+e!|zl5 zdc4;}jgq}>>5^Zzt-baF!7R?lk3y? zU(<70W=A#5Wk(Ip%-#8Ql4b0*bF5v16MM|~e0J1}Ve(6xmb9zCycaqyJ>%nD*KW?< z1v`u1JidO_ZTOjk*N$=4&z@PAn!N0khO_*;jR#MBik-f~r!;3!<6vFqw+l1w%kthlsGDftTdr8XF2LPm+=sQ^J^DPa%}jfxqha_+ZDs6M9tZ2bmdg< zhbdICkHvND&MP{6xOl3j{Mt>6yS;EbT_e{^ZgM-g>~IOo$5At$8!JtAvW`y zulR3Wdr(*Qs6$bOGShmt#F755OeiN3K?DGRjV>m zR>x)Y`HD|N@~b!B9@eccy(ZdtNp#eqWjD&p#;@Y4b~seJy&F@>HBBhCnB+V#Uq51(cCw)H(D;pI!?p5rhRt7JW%&C001x$Hp-IOEBzs?0S?oI5YQ{nnaml>? z#slLzJhMLcuikgROybgH{WHdH9VagyZe~1KcW~KPpO|-ibF0B$pB9d|8O19+QTo<& zKz#1zt=-1%P8hR(OpQT)!UxYajB~P&ZVF~cZ(}dKA!t5nGU8K>qC>}FCHrx@*;a~a z^w*p0#;2UVRyAg##j5Jf?TfuiZ#|i(msmEtE;+b-$^0D)o5#)=e?luX!o{h7@tT!O z$EO9ga%);8{D!>Vt9_)Y|I-sIOr6-Dm$8;Tzjt6~!M?k%brW7+4lA@96m)Tdz5kvI zYqzeIqg`CVv8+7tOiBFi{G+yJO4cU=tE5VH-`|?FdiwJoVyav}w$0@uuk*{Mv`tIZ z(U5akVxPa=OEBd_eXGvFF9m7$)zjCFELk)lSTpj=qt8=Mt{b!{YPxAtuZoD*?JH&+ zaTD!LqecND{Vp`x@zu7VT+h@k1WQ9X- zdNL~S$u7>j{`D~P$?jfR{kNBuOun^avP8^I+f6mDqnquG=Dr-WYh8lQi%YRf@99jH zw$2U?N;&rY*!Ge~Ig^k3%S^m7w(>xKwOom!jaPGX?d7v+yhVCZp%*kS&t7stTY9B8 z?PiMQ)YWY|v7dId8OrFz(Uyf=@;8qD(&td+@s8_5GOY(qIGMP(_GtgC?|G+_Mql85 zdTQFT?}gzp&FvR!TXYs)y3=ihflH>0c00GR_f4OR+mo)`mvO5Ut3P(6gm>}GiKKek6nXREBQ<<9-_Ef-u)AJ^K7jKq zQ97d3bbVjJUUtZl%r8}&^HSFZ+aC8FK66#~I?2|uvbCYdR&IF7>V809PL*@y_;Jfo zA0kUumyHUVJ?MSKe(gMm-pw@)hd%V?m>$_<-p6qA16}|}`{}+XtI9p^R`hdqT)tjI zV*0A?MdmXWjoLEJ>{VfO!>GOcCf%-R-Z~>*$5y>(x|Z_2`+}6#06T-aR{tI{r(2sP zmv=ZTdsS{rQ9gI~dZVe%ib5+r^CPt)Vz$l7!btL|RODf{cTUoRSx*{fS@L&~z@J-#$H?u;+g zWa-bTcI-7MWyaCnuUBT*>WB@sDbI5~VqhR}>bLL8xM=Z8xt6tNvZsf;Iw_^ZUFFoB zT5+GK4zH+8A^ z@U)_gbgc-_ybXB{+0pW}mk*|&S+w6VM()I9mu}8IOWmCI&U?6Zj&f~%&LM7KpXOt` zyGayy^qtp#?W^EREcvv9m#$rKI^o-G-x2k0-_C7Z;5JOma?rrD+*x&g6Jw4p%s964 z8Ea<7{N=|}Yz`EyO>z4WsZ#OIy4PEu12_6iH#=b7?6lKNca7^S`lDoTy>k!k1NudHx_N@@n~MouZpwuWZLujGw*Xkb}qF zjYAs}hRbrAEZ@y2aevTuwPcJ|PD;&{*UO9cHx#e8uq*1bzxuty;$3fhKJ;n%I%3S= zgH?-btAdl(SHF%k_^L4bv#ZUHRg7`@(eeGVhFfNseEfX*9gT?+&ILCY@`%u_r0* zGfVwre943OA(Jh`ZLcVt%CIqs4oUM{dsb`t+6}afxo6fbQIZ)db~Jqd;LpWzw2SY| zJs-%esL*t5TyQsRVy5aw=Il#v6u*AD@w&I{S})1xClfxN%uzYflDx}(!;ys!eHxw{ z23&nsZ!k#0MRjdTjBeJI=1aChXfvZR}B$G@MFn)zhh*;DH`yf~P@ zEPBo<-LZEH_YL_Rqq>^Q{xpVewpB*v_ADur`OhSUAeD_0RY~*#H91q$j z{(hH0yE1uVkksXqD{t88+8#}^`tp6ZW+kWN&E8S97CmU#r{`WFs#Z42vl?9n`Jt+ew@G&uiA7zBN|amld(v zaM)qrfW2ZRW{EQU&y-!r>7OKqfV%P2r9tQtV{{|1c{L7zErWE&!Y$@}X_=R8MZ9m7YxBMKR zSpIWdv*o9FTw3~1ao)*OKgG5E8-I#_VQly@Zhdq_@sDxtuA8rZj1PR7u;zz&Tnq2T z;UD6e2Klbfeu%S9UsO){A%0Hxbi&M)tZdla5~6IIk1kDIS_ zw14gG&iLxWK*OlSq|W%EX>2RSIr*LOthbk|l*?|2;+Y8w*6x$0Cy3$~cJ*3)d{@ve zQGAFDuSF}hvPu+BkXqjwWnr~g7`J}TIc{1jk(wopPkcDuhjr!R`-{SOcAENPJL{OB zufq7at%rjLflpY!&1U-b{R&ZKZ%} zZd#_(9i?ymp7&0f(CZDxB@3!uPMK9-J$9{WEykZ;%9>Fm#uU@4C^!mH>utjv-t{^^ zqGI3CwC51NDt2Yd+@M*n7gQN8N`?3i4cd~r6(8z)FFEaU5NcaKIBv&-K>cl59(pE^ zLCarc#^co3J!I_KI;`(X8qN5!dP{%1TN_4n7h5%8FAaRg585A`Hg>_yN%qYj?$WGf zT_YYy50$y1`C(AR?PS^ozjj}C@-9bOW7Cm!-3w^*?dG$(y-t}ES6`5Ae!V8{_N{cg z)!8BZ=6P?tJ$EjhI5IJI(A}JolLE%)SPzxX)x6{5dSvzLO#+Fh)f2~5U!7ac|NQJw zOUHKGw~OUc7ca@~yKH{&AOO$q=QhD1rd6-uF z*_#GCJl{ST)99JEJ9liWO1q}3-R$*#O<}|HFTF}Nt+Qx6ax46}?I5`n$8S#$+PYlG z_ZoZSrQ(sad3h)Axj76`eSJ!%ZuJ#|@Amah%T7K>&d%N=uX>n&swCaBpuk_D;L5lR zXRoK%blxr+nwD14usk!^?dYOaJBCiFey-Z*YhKZXmF9wn`zpr_7~#6BpQYTLw!Mkp zdptO`?SuT$?oFc$&VSWWIIXkXY(!Lmp|43`+Lr|ucXW>zvZka-#Fm$hZvT8YDRutK zTJib?7iWhV-T!v?)uBy=&51kby&ZN!JJa{1tcH4NZDF2t)tqjx4JFSGx>Yc6U$@)W zSJTT^XIrs9-V+q`PLVtx-}X5AZiP?(=*d=7v-V#)mTf-0=bB^m;A#D<3#4X$dvPT( zX!ha$jInQ{+&L99X77tTBsSB)dGUlPw=7a3--X}L?0bIyus!aczGE-UtC_n_{$jm( zpDVqFoMgHVsd5+{<=n1uUSOR$s(`hiuCz*LjMCPKEmqoI-QIX)sLr$bqUv&Xef$K& zlB>HcX@YL+A_ZX|qrILjYOqbc#B+Uh!teB)O_hDdSIe*1wCGjDQ$M?=veS!l`j+2* zYqf2M!sc^|1qYk@a9@8IUtfLhc|)9Kqr=q=at z&EK@5+^HqKZlu=+nJw*eISp238Hdv!r4-ICS;jBX9Qjh_9PQbnjR&S38Qid@;jQx% z$4{l3XAgVy_L-T_5uX8i0WF)H`_4>U5!SebcKva5Nz%O1J@xN=_Q>wu87Dsdc0>KD z;ND)1^t&6@U*?Sp>i+70bK>gn#{A?5_hS`SiAfneY|J$tzGTww9yhm7Z?+#(lJ@%A znJZ79-|T%+BDk>Uwt#Jh8kPKZMYB8yDl#%BRDS#P`NDa<&^w`v?vA6MmEFFrE#txcZ!dkcRVQW9O>Ws& z9HaM`^6kmu1A<*rHf1Yrf9`M7J3nTIx|*wmz3=pCFEgBd_tme83O6!awy|7KC+p0f zconbxwhtH?u{4E*M#+$UfL~Zt$f}2-mgcj*1I>S$SnOrQe@8u(OGp<4z z95ygu}hwNc(SeECg674Wr+|T#nz3zAI+6var@l@J+FNwvx zwRY{q+SXe~Y=*idT+g>FJGXh}+QgZO2lDNT*J>>17#>~n-gM6U+&&7mb0P}^QaZde z_S!ONXjt_T33Sr(JZ5cQ=|>$A57gSiIpt=Ek;JhX!tlcYnViY{vQrkCKO3gt>*};~dNUwsg^qw+qYOwAUB$QzSwYPRXY_E2tcNG2g4#_5Bx8`|Y`X zAaMFK*UU{N+wC8o_^{_ritDAIMoU)QEscidQ=GevI=#;?yEd%$T@-)3ZG>)< zgk0GHM)ipn=IlD3FY6b6v>kJNulwSUQDw!AkCj#L8!B$gRW8mlR0{PSc*nzQ-RaFs z*X+=~^!j?yQ0$_kHx!O5n#K;TPR-Y@ zEParxcu3iATEcct`G*_tzctrPQpwt3J6AB`<@BhtN4KT*JGejlxr5hs1^3{z!vg!0 zjcO0OZFd=#G(B4St9r+@H?MP@u8AL(&c9um^dP)Laozjm8XL`bxl&c9>ZdrKzJFBj z&2q=NZ)K$y>uL_vZo2WjZP(nq3v(1xxm&09jtmoK%9X02UO zvu761g|}|x|)kZALh@?UUmKXvg_X)Ue79W;Z9XZ>9&8Q z>)@o}dHuqAhOhVE^lsvVUXh=*$IIzm)4MqISx4IBR{gW^T!o~0?8U|nZH0oggU@C;Ub~amZCn;V z*P>@^Os0x)o*nnb#7rqU*-;PsjH_G2TQ=x*ydlfJfc@5Cotw*%IsQlLvaOaXO&yn~ z+Iqa@nT>dzYE_E&)&e)Vex@Iys_NtST#xJJX5$|-sP>G$l1-iF42dkYR=LEPpT-{e zx@EHJ9{tf5wT^7`d2jUi;ZWP$>^m`=+xPEWNN=)ESKPJymAIrXf9v?fMz;;xYANH3 zc1SLdUUT-T*1+S%?{nVmaIRe5P|DkE$M~SAfW4=DPv*m~ydsyp+lrLUAxO+<+WNfo@ z$BvCS@y_g2@0-2nZk2ahbt>H(Ghps)tziT8&pVbq+?mUR&)gkkN_Hu~ghImfGDq_kGg1$^oq!t1rz| zJ%2!sJE^IjH$3dqVB?Ylby1HLr}XpJ%pbR=_ZI6TO(_K{Ql@+^JF@I*Z(jM;odqFj zd-e}F9I9EEkoD@r*_BgehTiQHwqvzU?emNCdbTU2EfXZKO%}|L$fx8I?Qa(C zKKlB5y7KB14-BS8Ep5x`QzO_lJXSqypwmMW|8=vpjh4DAT}^tkifbzU!5zg3HBiyR97z zS>~oKqpF_9Oh2@sqUP%T;bIjd_TOEsd_O3wcPm?LeM;id^$)ZS*3>`G=5FpEuhQ$# z`wMH*Bl)maO*8+?O|pM6rG3&PhK_qT4NW_gj5VbA@-@pmwdh z_58H^UlI;|daD!X_UX(1NnY1aIGX1?3H7zeYz>W?ePEHNlkqc&Rj;0Ccr6&kx#v3j zq#ynM=zSh{2M^2WUA5+Oxc@o2|Hj^7L}^!sRd^+T9$ zw$tp`qj@pIi-QhWoz<5ca^;PQ>+|c%RoY9dbLY<`C-2cxozJ+3>tZ7)xGkKd%tUbp3j z(e|ksr>_M{On4==*yLFG1=`4lIK4#n1rLw0Pi%5p+De_Z+)rp-DOp%jeYyT+`j)7T z$5d*};|4z{WLnqtJzYMv#l3fuPO38{N-K7y>roFlIG|4-*&ijQax(V;>l(`M~TI&1f8!+I^2WPZOuCM)QpOq z&m5x5^40H+n;35X<^ccL$}L-!jBdV}WwS4xeKcnOmi;r$Z3de+st*42^>FRB2h43D_W8=s4z0b{ zYuh#Zc)zk85&~F`9O^q?z#9&y+3-1t z2ZwE3gCYbWa|G^QG}<{h4>Az)?PpQvz5Z7IpVj8Jn@ZZ6hCL$JmnR~ z*VRw-eQ~92eDt>g88d45AW!Qmw=aZ$tRGLV;CVVxdo&^34}SgO2d9ca3KAC0Lr}mW zrAT-e2C$e2Pi&7E{P0YiD6ckz2fz>WivH*jK-jtS;J`T?FoIKPKD@9HcRX|dj}9sl zp8OD;$3kxXJ(ig3S^SfPW*{4DrBjp=?PBANCvx3HiBfH+W~SKx5mp0Vd2Qwm4f6(#LUjLFfp3 zD&!Yu)96fbadw3fLyR_byduDzPNVmdf?G3L%h`P-=`uXFmJE%3l1&rOVE2dm6d@m+ zRASR~q%C9_G-XYeDqWJED0YcWlk6p-B{fD&Q9P5u;4*ZrrHmPUm}A7|NcNN*AVCw? z$J*4ku?Mn(B@+9@v4^r(vn3STNe^gjZ??F?SZSKP3&f|YK7%%!Ldd%ZEeLDFw$dda zqy(o#p*PYB0ljF3_=U#)%%(}jv1yicCY?1_hb{v+$fmi$p;2$C$24nhCf!&5u~?&` zo49?iOz~h|ri7bjrc{L1WA?YfZX5~yOwL+^#~fZxrnG(@uX}SrW_NA}k1IiU=RRR% zah)aIW!t2m$hmdTQk#Zr?s} zfqm6lg51@bFK4NhUVoxiRojUzq!fcK#$j}4ap|%QIWc(^ z1$qyL5~Ei)6){ywHM%Ccrd?%uPv z#N@GD(z29otZv<9A$e!{c~y%hwLaDH)q}^|Z8|wq|DS%+Ad#Dn5Bu zoFm;sb%>SSq@3K#S287f^;YjU-0IQGhNg~l6)c`czy8`r=0ip~jGgG{G}U>=tl4g! z0&oA&sD-i1vv=>^S9*2N-oT*q4<4?Yt-e5v$Wc6xotJE$u9ro|01fiei14%3{j>%~@l_^jK^ODG6(y z7E4;nlsQDKw**UCV&drkue~pUkE%NRzUS^U*~5~MjfBlW7G~cFArQ96B8Y4v40rCm zLjuW6n3=F>tHa_BZpCWB1r%)+6}8s7fJ<9(dF#^eb#1MJFZQ#wRkU@fzUccu_fA3x z3+TOE_bn1! z)zf&tl-D3+NS2#kA6c%%cN|{l%ps*BHY{7W>2iLBki}V~+^d%+4|D4t5({$ja;8`k zb;-}Iak+iK$g0$CgMLfH%VQ^kRAnRTk zm3+O5C&{NgAlClm7bBQi_7D(xa1$jOrGRq@;(f{Qm*FNY|9zz7RaSs1~-N;!!#wo-Y7uF3xX)Jk|;}- zJZnkDpv*y8x!IXHd@h%t-_J6T6!3*)5LaX=CME3Pf#qBkTa!^sY`mRykh|Es`Cal? z?AO9K+_#o{*Q~vA^KG{I3$EOBP063LbEZxI`oC*Ok2`O1@V$+jue$cSyB>J#@n`lu z|H3;5-~X234UzB$#*A$`bMeNjaPy(Z9^d!EOD`XMpXm~qF;rrfX!^!$x83~wOD|{T zjSP&L)HHw5lAxw3-nCfioN^KSOw zNVKFh_~Q%j+x^bFGalbFu%K-4%3E(p-t-ORN@7<|K~g zI4+YHxD1hG4-jTb#nOC<6$&$F@r_&!G+dsTlNsPkhX>2s_~pZs&k5`A=ZeJjhq;B) zKue*8vfOeAN|CrwsuCt!t9dX5XV0kSi^L2rc@J()@1OjaT*u{b^@2~X64rm4S16Cp ztKo)ZSL7r&@$0t^%ouRl7Gbn72K-fMNj@Oy`qVh`V-X7V!2R{JKAmkTL~f{V&T$iMX+u zPd>pFb2$_rRwIW3wRQCS&Q;y6DHinL_Z{4yhU0}9Cf4e_z7*H=nY)RV@I)veg9*cD zW(yJ_WF9HaN7i~C$;zosAf!K;L#~wXBqOjf*vK=o@d=B61T({zW(YnaWrvB(%RFc0 zSdweY(hDmrC@vJT{rU}(GK4}RNkkrH&EzC;I>{v*pOe*($SlhaBxsQ1IeJcOgaIN# zCW}6CMC8r;v@MnwaD_T0^ePV%K`iJQEsf_ndX6vH=I{e}l^2h52UvymomoJ@xC{a|N@HF{A>$Zdey zLe4yZ(kh@wo~0AQvm^0a(RGzW{5WqMo|`+56|q-O9w`#0aT!woi~-B9=)a z7^Irgn=P;wSO$+rt?&=f+6bS>Hh`o8<+RdKrCjMynUoZJaJOGpe#8I@S(QUdFjECz zjiP*=D>^u?)Jo)mqw;G96c<<~R|!_Xg=7sXaOUyyPzX;0;Q{e5z@hobH4ag$H~0)a zv`YR0@O(-(yJUz;h#-}q2>Lk!(m;>K_w&&03FsN$pDUX{W%v;fD-9BdjH9Y!jE5yt zirMS|(xd)m4TB+6;2@TiL9!rQi)FT!rA)#WJ6UVqRDt9-Et3~i47QLO%3by{=!fhk zO0#OrDwRkSECg4Q;rN9nD5z!%EP2?hhl`T4m~b@jcZ`z5QVW3!0BLipxvGN2dIHsUk+GQU3 z%L$$w59yO}EI}W@C7eVUb`Ti^9eVVy%mA*uCILg!+65D}SfyOTl;u}5B?rq`^73FZ zP-gc_l$N0WGh-$~`9KwuVqDYzR6XMd2!4TRbhY!uUGY`MiAMd=r4CmBW>b$-m=jGk5pT#-#^*is=g<&)v(RuwX z&S@M1KQfUySjy)gyYs`8<)de#y zXy5RY4Zq&-_6BxS<)*VXt=@9$mgly7dQ*vD{)5_pu!t<^fHQg`f#+Z(7@QJ|@v%h` z=?z|%DL)D<59%4Wk)lvyXh9J=$Sln<0+Gx*2$L8M(sc-Xszov?PiQj5QCEFcNFhi^b>x+!$UEC5}TcU`35SL+xX}Kyx%Bis*{Wh$a~& zRua%*Diboyk6>Xq&ZHqg9j67RJI` zc!>c{VL^Wul@Nh3Sq8{M0@xH7Sr#!Du<2;JlaW|f0^}4W0l)+F0L?)(bk3XzNUJE* z8JD19i3sw8dZ;_ac7h1VgdxZxLU}TbJ*A>-v80%hl>u8Y4j#0ju{^L5FczGa6pKO$ z5k^MuKqAOE1ICg7l6VtQ~V512AT=o2f?Vuw1B1I z+(6NCDJ};=L>O`zoDSP4P-YY*uqI{#q%@dcmZ1v4$LJSh@H7B8I6*+x6FwypJkK)- zDKHipjezMWF;JQnMTy0XnKB5`<9V<<*bBnJQIgQ|K=UFXm^ty#a15BAVR|H0aH(!pZT3K$PKn}Q8fS3px> zoM23<8Yl;Y8z8ze1W1D7gmk2s2U-N=0h@xG42Fi5f`Z^7Qb4?rH7OqAzl~{Dw)vOu*w)bY^tRVG?YQ~S?(y4)K5$_Be?R#2 z4rULzoq4t5_B&r!b~5jhyRLcfz^+#g9=MPBNZD=s=Aa)eJ@Se zbKt}EdzO6kn?1~z?B24khU{gS#=X<}se8|NZNTrVd!b4!S-JfRib^Ynol#Y5cl*XL zYf?Gv=3|^-MrKiMZSCT-^>Cw3lc}{LV63f0x>qD8U9D?OJ4CGpyhL3PGBv|CAeZRi zNuU9KC@Cvmlo7C4NFjJ1W?87>##lxbl5*g9h%%f;$;y_J04U?DSr$WUJgJA|x)!nMGU`V%^U-cr~I%OF}=Vyk5{`|~y{&yBETvgJ@S zKHNevc*!h#BL_$g?~Q8reGLrxZ3V+^CQHj1u?2!ptmW)17O@rdd=NzY2DT_ai;R#5 zWdL4sHmbDH-Z0V#+OupXMmCx_K>(O4jC>R{$VZfL5N#$mHy7HFyhpC5dIUzk5<2z{ zv@u>_*csyF3_E`T@#KueSgo8L^-5$cHw@OLo@BBvxNcPK205r0)Oa(*e}F+m-|<3;6{UrL;Cb2e*8P9z&0^#q=&7UT#oHr+;A_VVl^`h!ygD4OQ5r z+*&CbvnR4#Ehb?f>L%oQ3B)324>Z6ddp>n+FdN`Q+8p#?2I~?8t^i{ebFc+6aLO21 zuyOosa1|&}%N9Thi_k7o8NUS^9P$pCWRrmcqWWEsR3qC_W-RpLH|#%Y^`Jc?wMop< z=GbrJh^9 z-R?O|D!jz1c!yi3GVp@Z1$DA_dz&VGOD|63^9+-Rc9%UZ$vNB)) z!;bmPA1f9x`*$q7@4bpee?NHOyjMO@7MC+0EjdIk3PLRzKQz8Ue>C&Jd;rr;e{v~^ z#n1Lj%qJTrf$l<$bB^#o>n*TrWK{Z0Euko;`Ebll8Y< zbl|?nnm(_|I<#l);yKZmu6Xxn=l=EW_}bj+>No$jMR@w*s_k!H+w#G*E4CF&YyUlY z}F-|sK(oe1OWgR)^{ejKIDgvG zFKiD_BbQxUf8m%{U%I1aiO;?F_FKmP&Hd8iGcTX;@}nJ>tiNZvc=m$_wx9pf^_Q>v ziDkir{%UVX*4e##Ax zFoz!+GWYr$?=Qc6z52kWCGqlG?sv~!9E?0PH?-%^qdnLB;+fJ7ce}p0yyC+Ps$P4% z@uB=L4i0^dbo~9Vchrp0=iYt)imegP@QUZ14^H{=@+bcG>P_O)){T*t$Dg|8XRE3s z!>tpiev&o(g~q?Ni%-4qCvE;Eqh9=J<@_bfuM>ISp8WcMoY9fo^XcC|IU%0@2>7t20DXrN5_41E?dH(cU?mOHZ8}NuW^3BJDzb#$( z?xdoz+{;CO+3UP&*LCDK~%qR`mzZM}*zC-eW)G^8a(*kbqobf8vFGTc0iXrhS+A zue+yO)xB*$UbF7eo5#+0U4G!TKmPvlYRk+I5B+5QO($5|rUNPbyzM%_R ze?Ifm&#jMqI%@ab(MqX0GUX2k?t3UJy!*4F7bdOU_@|w}Uq9m?*F1OY=C@|m-Ef1R z|I$UbZ?F8-W6~!%?`Qt_@HanwI{5qNVxha5{xPSlFON-M9-F>AHhp<)`tsQH<+16@ zW7C(%rZ108UmlyjJT`rKZ2I!p^yRVX%VX1*$L4=4kIjWW^4Q$cBae;HBacmEk32S8 zdgQV3_sCA zHhp<)`tsQH<+16@W7C(%rZ108UmlyjJU0Jd=dm&4K!?Ve$6*cTaiMu^xY|5k_FMC~ z{7d7Q+*muF!OtuCs&U--#tp_%fAK|nEDvsHC*X(`lU{nfZA(!bjt%eMWV;Q=Ys!AN z=XD%iBR*S^*~ldKd)NMUd?T~{&5P%|Ry8uu&0N;@^sYu`?6pe|E;!KGu<2K8N_P*K zIP2s0UO!kgZQ^yW%@AKcl$?lqf0&=~Z(jBrCZi<3TWx%|bK~@pFi*F@W=e`RU5#o= zYp_+pKFP{5J(!3_TjRB>m3SNZgML3Dp41b80Cs=I_U3`WtkluC4q}^UeAcWvbca7| zb2!uxcAnK8tnc_W2Lfhllc2eAJ4%Mskfy0&m*NiV4$b4@99=E8>T76&)6GL7xJjjXZ1eITGlkyFChS{sjrkYWWrqI;zW0#lWU)~eT?^tqXM z8cXg^{$QIDTR|x>qa#s0t$JSdNo(#bFkM%|^}T<561J(wNLwOw|N0=deeQ_Gkw6BN zwz|UqS>vxD#>+p=G2bagAkwC!6oDm4jqX{(dHNtW=8Ur1$D>X>n5^rx+ z)}mVDvf1l(W4B^^$fi4Vx6P+YQ|iJV7cF#tTg!5=SFB|fcAEy}bp<&)P|nyT8w?qw z4+PD9veBim4YRBGLW=HD!(N9b+q)R%xGYMGg#E6ts(LktGZc1fApu_OnP@U;0LhN*_^I=bkz`P?3-Q}<*} zOxMpyM;pXKR~_M2OchRAz~#ZXzA`1|$d=IcQI@}VwHUTt7DNRP+7 zrr7GCj%B9M_Mb;v0m&&-Yq4m15ShLp(`uKBTcxWIeqBwg6R7@dR*-)9!PH zytV;TJ2hWd`E#m~@3c#QMBAZRX@k%r_=`Hsi)KHzJy-l57laP`n)_V?ed*}X5ov*8 zqn(enL=sA<6{junVAoZ_nDiot(WZ2~DG|-EF*d)?r7PI#-0t-$g)>i}h}#r&yD5^0 zHYM~}9o5?7=>TX#u3$u8gL!H8gxsp)awrV6y0g}`yJts&rP+Y zw?6Tx_MOE@uP zT&M9($1H{-F>=pA7AMD|ZF3ToNMW1>ac}6f@7Y}3Q`kkjRJH~=c`x~FnNx=tTGAFX;@3)P}(w5`1( zp$Cy0P=OLK?Apj>r%_Z=XijbJh^!dpFvMn&#|_O1%q1ALU1o!YFM*5Yo?|qzlZN)_zNva z{MM!Ej7g8{!4MS33e=>#G|i(bPFN9_%^7mnp3Yh5h_tpuR=@;f7DhLpMv7{{+fj_t zXvsD<9dmXW#?(nrQxafzVENW)bVWydkYX`=THKbVxYF9*tc3JL3-Catwm|-H!KwzeUG^xC&x9E`j?l>77q`H()*b`RWKDW=|`oU_} z^^gbNEMT}>4eP4vp51#U)g$qam>ygmjcLIU5S*sO)`D9#N7xv%_uls*1-GuB(nG z!0Ij0Kwy5Xg}T6|=ZpS>qz=Fp-LBh|u%bBOXpUWCcIkM!{OF-}b|o#mFj|9bn9Wfb zw8*iz{XZ&gHynXS6^p0-I9Ik*+QX7UaireLYw;R$zewVEg z*$j^t$vd7kOevZ;5*CBkn%w~HVa27|JwBUX_iGa?gTYuwJfSYqd^7GzY}0J2Pw{ysAMGj{ilh<1h^o7~`PGvR zNNh@|DgVY3b2?)j@PN9j^56=cYDgdhm)jN!`+chF@p|O^`kKa{aJbzJR}eVJun2Zr$nNrZ9g550 z_j+8~nfBfecXdmmIoJ$4KW%nOImVRLLBk6_TUiZ9zKP=MI_j{-bo6T#_ybXd)OirZ zN>L00@hKsP&#yQ_h}q)QGyO;DY!9-1jMs?$7?t4z(}r zcY>dFO?8C4ZpC@_`TtAOw@gpWu^Z0(Ne$n`BSEfnzP}_Opo}*kVI}NTHPz|Y=4P61 z)SPHXOx5Sf!C+fQYof(D|I`U{0o+xJ3WwT$yr8BFB^aUQK)^`f4(P5^eu4({hTzfZ zcDn}-s%PPX^c>N9m~cGj`P@_FbcfAucX(8%?)BMSF4eurcYH~yqd~wxfXYYEaM_#f zE-!plw`TY04x3l?p4a=5TG&Z-lh5n+;?+)$fzum3$x}@$Z9eZ04A<7t3SNknP5$e3yM*>tlqV_`P|b-oR-tsb^GGw?sRN$41hBn zS*Azu zc8{uvcsyN;$IS9~h3ST9AN3+SF)?l2+IYAtXoyjEe?8LaB)7-(aLbyG(I#j&!y(;? zW4iIpJ`di?`29Y=)2AuAO`F1pC|0ACZQMJIyeyE*fpSAeMGQk9h%z_;s2}PigMze>CC* z<1~FuqnAH+rfIIn7y^NAi0MKjLXUYoru(L5gl~0JXb4l@>~Z`3VOQ9v`Mq8&G;m%t zi4x`e)d6^&ByXQIpasWKhik7!BiKO*rp{a$U^d_NA$=2*ruW85ffPMbbxnw_snga* zQp+;B^J$e?Z|8cEIcp5gAyEH;XMs;3kBH8H!6o z4A71xQ?`rAydT0&D-lFO#z*LKn^aqu5N91E|AcS+k1cg6sZBdKU4FEwj?EP=myyb} zwCoXWxt!#5({ywl!xiXby3)s}V>3#L5nV~nsTd2QE_{@o@*UlT#}9$M~Nvij7u`u9g5@Y}B=?WecpV~P9|vYS0Y$mKW+^mv@s zUCNQrq!SR%754CqZWqzVoj))O0*_PNs9_S+(R^z4CDIJd= zj^(rKd!dGpE%nn*Gh*B_oYPJOYJAch@;EiDAHsShhu4pHW;gUkXQaIB8_Dn!=obTB z8Yu2(Ny=rIXrlH+#bfXz8YY2HZ|rR~0o4C;Zv1S54i7Hs!&=DSA#?l8Hpr!ntZ zD(|rSeRd5mUEKZ5yAfw4aj+X}qXooVHXr z!+gV_YeC}y-derL*>_*)ntxT+*Z5 zx$5$Y`n$+RavGaIh7MhUhi+~q?Z@53lcpP~5omf?LBO&*!x`k;MS2tUpwUh&f-${& ztQpklu9a}+PNYbTz8~{S(v-S;NX^MrMLeNkl8kEZCG{tNJ`zohjs_WmSX|o?K^0hO z8(ihMuUA?O+YBUjcUrpcPzwHbEV>FSzre*_XGnE9Js~V{)$I6M!~G;cznv0H1(OUu zgSTv~vO@fiE@;I%k9doUb&JhT)$3Km3ck4z_PSkO6+5w!0Y_n9EYgi2rW2R)vHMXF zDhdo7Y>(1qu`vtwq?Kx8_<~GAAwn%ZFjo)@`lfZLdMr*dajNR^xUSWN)^dXJ)_jb; z*6*&hl~=m)g#oVz{&Bg(=J3?mTs3yr$nwfiM@ws>oO;#RfYcQ2a!?*GFjNqJEGPgW`s3~YNCd2R!kS%S6Pn)jjD3mI*fU&S!TRjjaT)H oL_t)gy&Z4PYr^dbN}Z}4P)(2N5mm3D9%sBtrVA!(uyE^t0P1E^T>t<8 literal 0 HcmV?d00001 diff --git a/packages/decodal-language-tools/decodal_language_tools_bg.wasm.d.ts b/packages/decodal-language-tools/decodal_language_tools_bg.wasm.d.ts new file mode 100644 index 0000000..e2142cd --- /dev/null +++ b/packages/decodal-language-tools/decodal_language_tools_bg.wasm.d.ts @@ -0,0 +1,9 @@ +/* tslint:disable */ +/* eslint-disable */ +export const memory: WebAssembly.Memory; +export const formatSource: (a: number, b: number) => [number, number]; +export const __wbindgen_externrefs: WebAssembly.Table; +export const __wbindgen_malloc: (a: number, b: number) => number; +export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number; +export const __wbindgen_free: (a: number, b: number, c: number) => void; +export const __wbindgen_start: () => void; diff --git a/packages/decodal-language-tools/jsr.json b/packages/decodal-language-tools/jsr.json new file mode 100644 index 0000000..bc89ddf --- /dev/null +++ b/packages/decodal-language-tools/jsr.json @@ -0,0 +1,15 @@ +{ + "name": "@hare/decodal-language-tools", + "version": "0.1.2", + "license": "MIT", + "exports": "./decodal_language_tools.js", + "publish": { + "include": [ + "README.md", + "decodal_language_tools.js", + "decodal_language_tools.d.ts", + "decodal_language_tools_bg.wasm", + "package.json" + ] + } +} diff --git a/packages/decodal-language-tools/package.json b/packages/decodal-language-tools/package.json new file mode 100644 index 0000000..1711d5d --- /dev/null +++ b/packages/decodal-language-tools/package.json @@ -0,0 +1,27 @@ +{ + "name": "decodal-language-tools", + "type": "module", + "description": "Source-level language tooling for Decodal.", + "version": "0.1.2", + "license": "MIT OR Apache-2.0", + "repository": { + "type": "git", + "url": "https://gitea.hareworks.net/Hare/Decodal" + }, + "files": [ + "decodal_language_tools_bg.wasm", + "decodal_language_tools.js", + "decodal_language_tools.d.ts" + ], + "main": "decodal_language_tools.js", + "types": "decodal_language_tools.d.ts", + "sideEffects": [ + "./snippets/*" + ], + "keywords": [ + "decodal", + "formatter", + "lsp", + "tree-sitter" + ] +} diff --git a/site/decodal-site/package-lock.json b/site/decodal-site/package-lock.json index 6abbea4..835852b 100644 --- a/site/decodal-site/package-lock.json +++ b/site/decodal-site/package-lock.json @@ -16,6 +16,7 @@ "astro": "^4.16.18", "codemirror": "^6.0.2", "decodal-codemirror": "file:../../packages/decodal-codemirror", + "decodal-language-tools": "file:../../packages/decodal-language-tools", "decodal-wasm": "file:../../packages/decodal-wasm", "marked": "^12.0.2" }, @@ -33,6 +34,10 @@ "@lezer/lr": "^1.4.10" } }, + "../../packages/decodal-language-tools": { + "version": "0.1.2", + "license": "MIT OR Apache-2.0" + }, "../../packages/decodal-wasm": { "version": "0.1.2", "license": "MIT OR Apache-2.0" @@ -3255,6 +3260,10 @@ "resolved": "../../packages/decodal-codemirror", "link": true }, + "node_modules/decodal-language-tools": { + "resolved": "../../packages/decodal-language-tools", + "link": true + }, "node_modules/decodal-wasm": { "resolved": "../../packages/decodal-wasm", "link": true diff --git a/site/decodal-site/package.json b/site/decodal-site/package.json index ac74f41..798f9d4 100644 --- a/site/decodal-site/package.json +++ b/site/decodal-site/package.json @@ -9,7 +9,9 @@ "preview": "astro preview --host 0.0.0.0", "build:wasm": "wasm-pack build ../../crates/decodal-wasm --target web --out-dir ../../packages/decodal-wasm --release && node scripts/prepare-wasm-package.mjs", "deploy": "npm run build && node scripts/deploy-pages.mjs", - "deploy:wasm": "npm run build:wasm && npm run deploy" + "deploy:wasm": "npm run build:wasm && npm run deploy", + "build:tools": "wasm-pack build ../../crates/decodal-language-tools --target web --out-dir ../../packages/decodal-language-tools --release && node scripts/prepare-language-tools-package.mjs", + "build:packages": "npm run build:wasm && npm run build:tools" }, "dependencies": { "@astrojs/check": "^0.9.4", @@ -20,6 +22,7 @@ "astro": "^4.16.18", "codemirror": "^6.0.2", "decodal-codemirror": "file:../../packages/decodal-codemirror", + "decodal-language-tools": "file:../../packages/decodal-language-tools", "decodal-wasm": "file:../../packages/decodal-wasm", "marked": "^12.0.2" }, diff --git a/site/decodal-site/scripts/prepare-language-tools-package.mjs b/site/decodal-site/scripts/prepare-language-tools-package.mjs new file mode 100644 index 0000000..2ebceb1 --- /dev/null +++ b/site/decodal-site/scripts/prepare-language-tools-package.mjs @@ -0,0 +1,76 @@ +import { writeFileSync } from 'node:fs'; +import { resolve } from 'node:path'; + +const packageDir = resolve(import.meta.dirname, '../../../packages/decodal-language-tools'); + +writeFileSync( + resolve(packageDir, '.gitignore'), + '# wasm-pack output is committed for the browser language tools package.\n', +); + +writeFileSync( + resolve(packageDir, 'README.md'), + `# decodal-language-tools + +Source-level language tooling for Decodal. + +This package is generated from the Rust crate in \`crates/decodal-language-tools\` with \`wasm-pack\`. +It currently exposes a comment-preserving formatter that is shared by the official playground and future editor/LSP tooling. + +Use \`decodal-codemirror\` separately when you need CodeMirror 6 language support. +Use \`decodal-wasm\` separately when you need to evaluate Decodal in a browser. + +## Install + +\`\`\`sh +npm install decodal-language-tools +\`\`\` + +JSR: + +\`\`\`sh +deno add jsr:@hare/decodal-language-tools +\`\`\` + +## Usage + +\`\`\`js +import init, { formatSource } from 'decodal-language-tools'; + +await init(); + +const result = JSON.parse(formatSource('Server={# host\\nhost=String default "localhost";};')); + +if (result.ok) { + console.log(result.source); +} else { + console.error(result.error); +} +\`\`\` + +The exported functions return JSON strings so callers can handle diagnostics without depending on Rust data structures. +`, +); + +writeFileSync( + resolve(packageDir, 'jsr.json'), + JSON.stringify( + { + name: '@hare/decodal-language-tools', + version: '0.1.2', + license: 'MIT', + exports: './decodal_language_tools.js', + publish: { + include: [ + 'README.md', + 'decodal_language_tools.js', + 'decodal_language_tools.d.ts', + 'decodal_language_tools_bg.wasm', + 'package.json', + ], + }, + }, + null, + 2, + ) + '\n', +); diff --git a/site/decodal-site/src/pages/index.astro b/site/decodal-site/src/pages/index.astro index bc726d7..9e5009a 100644 --- a/site/decodal-site/src/pages/index.astro +++ b/site/decodal-site/src/pages/index.astro @@ -40,6 +40,14 @@ Production = Server & { JSR package jsr.io/@hare/decodal-wasm + + Language tools package + npmjs.com/package/decodal-language-tools + + + Language tools on JSR + jsr.io/@hare/decodal-language-tools + CodeMirror package npmjs.com/package/decodal-codemirror @@ -62,8 +70,8 @@ Production = Server & {

Where it runs

- Use the Rust crate for runtime embedding, the WASM package in browsers, CodeMirror/Lezer for the Web editor, - and Tree-sitter for general editor integration. + Use the Rust crate for runtime embedding, the WASM package in browsers, language-tools for formatting, + CodeMirror/Lezer for the Web editor, and Tree-sitter for general editor integration.

diff --git a/site/decodal-site/src/pages/playground.astro b/site/decodal-site/src/pages/playground.astro index 09af8ab..1a179a5 100644 --- a/site/decodal-site/src/pages/playground.astro +++ b/site/decodal-site/src/pages/playground.astro @@ -15,6 +15,7 @@ import ManualLayout from '../layouts/ManualLayout.astro';

Loading WASM...

+ diff --git a/site/decodal-site/src/scripts/playground.js b/site/decodal-site/src/scripts/playground.js index 40c3447..a1cc8e1 100644 --- a/site/decodal-site/src/scripts/playground.js +++ b/site/decodal-site/src/scripts/playground.js @@ -1,4 +1,5 @@ -import init, { evaluateProject } from 'decodal-wasm'; +import initRuntime, { evaluateProject } from 'decodal-wasm'; +import initTools, { formatSource } from 'decodal-language-tools'; import { EditorView, basicSetup } from 'codemirror'; import { keymap } from '@codemirror/view'; import { decodal } from 'decodal-codemirror'; @@ -10,6 +11,7 @@ const starterProject = playgroundExamples[0]; const editorHost = document.getElementById('editor'); const output = document.getElementById('output'); const run = document.getElementById('run'); +const formatButton = document.getElementById('format'); const status = document.getElementById('status'); const fileTree = document.getElementById('file-tree'); const activeFile = document.getElementById('active-file'); @@ -176,6 +178,20 @@ function execute() { output.classList.toggle('error', !result.ok); } +function formatActiveFile() { + const result = JSON.parse(formatSource(getEditorText())); + if (!result.ok) { + output.textContent = result.error; + output.classList.add('error'); + return; + } + setEditorText(result.source); + project.files[project.activePath] = result.source; + saveProject(); + output.textContent = 'Formatted.'; + output.classList.remove('error'); +} + function renderFileTree() { const tree = buildTree(Object.keys(project.files).sort()); fileTree.replaceChildren(renderTreeList(tree.children)); @@ -227,8 +243,9 @@ function compareNodes(a, b) { } try { - await init(); + await Promise.all([initRuntime(), initTools()]); run.disabled = false; + formatButton.disabled = false; status.textContent = ''; execute(); } catch (error) { @@ -236,6 +253,7 @@ try { } run.addEventListener('click', execute); +formatButton.addEventListener('click', formatActiveFile); loadExample.addEventListener('click', () => { const example = playgroundExamples.find((item) => item.id === exampleSelect.value); if (!example) return;