ruflet 0.0.7 → 0.0.9

data/lib/ruflet_ui/ruflet/colors.rb

@@ -1,234 +0,0 @@
-# frozen_string_literal: true
-
-module Ruflet
-  module Colors
-    SEMANTIC_COLORS = {
-      PRIMARY: "primary",
-      ON_PRIMARY: "onprimary",
-      PRIMARY_CONTAINER: "primarycontainer",
-      ON_PRIMARY_CONTAINER: "onprimarycontainer",
-      PRIMARY_FIXED: "primaryfixed",
-      PRIMARY_FIXED_DIM: "primaryfixeddim",
-      ON_PRIMARY_FIXED: "onprimaryfixed",
-      ON_PRIMARY_FIXED_VARIANT: "onprimaryfixedvariant",
-      SECONDARY: "secondary",
-      ON_SECONDARY: "onsecondary",
-      SECONDARY_CONTAINER: "secondarycontainer",
-      ON_SECONDARY_CONTAINER: "onsecondarycontainer",
-      SECONDARY_FIXED: "secondaryfixed",
-      SECONDARY_FIXED_DIM: "secondaryfixeddim",
-      ON_SECONDARY_FIXED: "onsecondaryfixed",
-      ON_SECONDARY_FIXED_VARIANT: "onsecondaryfixedvariant",
-      TERTIARY: "tertiary",
-      ON_TERTIARY: "ontertiary",
-      TERTIARY_CONTAINER: "tertiarycontainer",
-      ON_TERTIARY_CONTAINER: "ontertiarycontainer",
-      TERTIARY_FIXED: "tertiaryfixed",
-      TERTIARY_FIXED_DIM: "tertiaryfixeddim",
-      ON_TERTIARY_FIXED: "ontertiaryfixed",
-      ON_TERTIARY_FIXED_VARIANT: "ontertiaryfixedvariant",
-      ERROR: "error",
-      ON_ERROR: "onerror",
-      ERROR_CONTAINER: "errorcontainer",
-      ON_ERROR_CONTAINER: "onerrorcontainer",
-      SURFACE: "surface",
-      ON_SURFACE: "onsurface",
-      ON_SURFACE_VARIANT: "onsurfacevariant",
-      SURFACE_TINT: "surfacetint",
-      SURFACE_DIM: "surfacedim",
-      SURFACE_BRIGHT: "surfacebright",
-      SURFACE_CONTAINER: "surfacecontainer",
-      SURFACE_CONTAINER_LOW: "surfacecontainerlow",
-      SURFACE_CONTAINER_LOWEST: "surfacecontainerlowest",
-      SURFACE_CONTAINER_HIGH: "surfacecontainerhigh",
-      SURFACE_CONTAINER_HIGHEST: "surfacecontainerhighest",
-      OUTLINE: "outline",
-      OUTLINE_VARIANT: "outlinevariant",
-      SHADOW: "shadow",
-      SCRIM: "scrim",
-      INVERSE_SURFACE: "inversesurface",
-      ON_INVERSE_SURFACE: "oninversesurface",
-      INVERSE_PRIMARY: "inverseprimary"
-    }.freeze
-
-    BASE_PRIMARY = %w[
-      amber blue bluegrey brown cyan deeporange deeppurple green grey indigo lightblue
-      lightgreen lime orange pink purple red teal yellow
-    ].freeze
-    BASE_ACCENT = %w[
-      amber blue cyan deeporange deeppurple green indigo lightblue lightgreen lime
-      orange pink purple red teal yellow
-    ].freeze
-    PRIMARY_SHADES = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900].freeze
-    ACCENT_SHADES = [100, 200, 400, 700].freeze
-
-    FIXED_COLORS = {
-      BLACK: "black",
-      BLACK_12: "black12",
-      BLACK_26: "black26",
-      BLACK_38: "black38",
-      BLACK_45: "black45",
-      BLACK_54: "black54",
-      BLACK_87: "black87",
-      WHITE: "white",
-      WHITE_10: "white10",
-      WHITE_12: "white12",
-      WHITE_24: "white24",
-      WHITE_30: "white30",
-      WHITE_38: "white38",
-      WHITE_54: "white54",
-      WHITE_60: "white60",
-      WHITE_70: "white70",
-      TRANSPARENT: "transparent"
-    }.freeze
-
-    DEPRECATED_ALIASES = {
-      BLACK12: :BLACK_12,
-      BLACK26: :BLACK_26,
-      BLACK38: :BLACK_38,
-      BLACK45: :BLACK_45,
-      BLACK54: :BLACK_54,
-      BLACK87: :BLACK_87,
-      WHITE10: :WHITE_10,
-      WHITE12: :WHITE_12,
-      WHITE24: :WHITE_24,
-      WHITE30: :WHITE_30,
-      WHITE38: :WHITE_38,
-      WHITE54: :WHITE_54,
-      WHITE60: :WHITE_60,
-      WHITE70: :WHITE_70
-    }.freeze
-
-    def with_opacity(opacity, color)
-      value = Float(opacity)
-      raise ArgumentError, "opacity must be between 0.0 and 1.0 inclusive, got #{opacity}" unless value.between?(0.0, 1.0)
-
-      "#{normalize_color(color)},#{value}"
-    end
-
-    def random(exclude: nil, weights: nil)
-      choices = all_values.dup
-      excluded = Array(exclude).map { |c| normalize_color(c) }
-      choices.reject! { |c| excluded.include?(c) }
-      return nil if choices.empty?
-
-      if weights && !weights.empty?
-        expanded = choices.flat_map do |color|
-          weight = weights.fetch(color, weights.fetch(color.to_sym, 1)).to_i rescue 1
-          weight = 1 if weight <= 0
-          [color] * weight
-        end
-        return expanded.sample
-      end
-
-      choices.sample
-    end
-
-    def all_values
-      return @all_values if @all_values
-
-      values = []
-      SEMANTIC_COLORS.each_value { |v| values << v }
-      FIXED_COLORS.each_value { |v| values << v }
-
-      BASE_PRIMARY.each do |base|
-        values << base
-        PRIMARY_SHADES.each do |shade|
-          values << "#{base}#{shade}"
-        end
-      end
-
-      BASE_ACCENT.each do |base|
-        values << "#{base}accent"
-        ACCENT_SHADES.each do |shade|
-          values << "#{base}accent#{shade}"
-        end
-      end
-
-      uniq_map = {}
-      values.each { |v| uniq_map[v] = true }
-      @all_values = uniq_map.keys.freeze
-    end
-
-    def self.normalize_color(color)
-      return color.to_s if color.is_a?(Symbol)
-      return color if color.is_a?(String)
-      return color.to_s unless color.respond_to?(:to_s)
-
-      color.to_s
-    end
-
-    BASE_PREFIX = {
-      "amber" => "AMBER",
-      "blue" => "BLUE",
-      "bluegrey" => "BLUE_GREY",
-      "brown" => "BROWN",
-      "cyan" => "CYAN",
-      "deeporange" => "DEEP_ORANGE",
-      "deeppurple" => "DEEP_PURPLE",
-      "green" => "GREEN",
-      "grey" => "GREY",
-      "indigo" => "INDIGO",
-      "lightblue" => "LIGHT_BLUE",
-      "lightgreen" => "LIGHT_GREEN",
-      "lime" => "LIME",
-      "orange" => "ORANGE",
-      "pink" => "PINK",
-      "purple" => "PURPLE",
-      "red" => "RED",
-      "teal" => "TEAL",
-      "yellow" => "YELLOW"
-    }.freeze
-
-    def self.constant_prefix_for(base_name)
-      key = base_name.to_s
-      return BASE_PREFIX[key] if BASE_PREFIX.key?(key)
-      key.upcase
-    end
-
-    SEMANTIC_COLORS.each { |k, v| const_set(k, v) }
-    FIXED_COLORS.each { |k, v| const_set(k, v) }
-
-    BASE_PRIMARY.each do |base|
-      prefix = self.constant_prefix_for(base)
-      const_set(prefix, base)
-      PRIMARY_SHADES.each do |shade|
-        const_set("#{prefix}_#{shade}", "#{base}#{shade}")
-      end
-    end
-
-    BASE_ACCENT.each do |base|
-      prefix = "#{self.constant_prefix_for(base)}_ACCENT"
-      const_set(prefix, "#{base}accent")
-      ACCENT_SHADES.each do |shade|
-        const_set("#{prefix}_#{shade}", "#{base}accent#{shade}")
-      end
-    end
-
-    DEPRECATED_ALIASES.each do |alias_name, target|
-      const_set(alias_name, const_get(target))
-    end
-
-    constant_names = []
-    SEMANTIC_COLORS.each_key { |k| constant_names << k }
-    FIXED_COLORS.each_key { |k| constant_names << k }
-    BASE_PRIMARY.each do |base|
-      constant_names << constant_prefix_for(base).to_sym
-      PRIMARY_SHADES.each { |shade| constant_names << "#{constant_prefix_for(base)}_#{shade}".to_sym }
-    end
-    BASE_ACCENT.each do |base|
-      constant_names << "#{constant_prefix_for(base)}_ACCENT".to_sym
-      ACCENT_SHADES.each { |shade| constant_names << "#{constant_prefix_for(base)}_ACCENT_#{shade}".to_sym }
-    end
-    DEPRECATED_ALIASES.each_key { |k| constant_names << k }
-
-    uniq_constants = {}
-    constant_names.each { |n| uniq_constants[n] = true }
-    if respond_to?(:define_singleton_method)
-      uniq_constants.keys.each do |name|
-        next if respond_to?(name)
-        define_singleton_method(name) { const_get(name) }
-      end
-    end
-  end
-end

data/lib/ruflet_ui/ruflet/control.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "securerandom"
-rescue LoadError
-  nil
-end
-require_relative "ui/control_registry"
-require_relative "icon_data"
-require_relative "icons/material_icon_lookup"
-require_relative "icons/cupertino_icon_lookup"
-
-module Ruflet
-  class Control
-    TYPE_MAP = UI::ControlRegistry::TYPE_MAP
-    EVENT_PROPS = UI::ControlRegistry::EVENT_PROPS
-    HOST_EXPANDED_TYPES = %w[view row column].freeze
-
-    attr_reader :type, :id, :props, :children
-    attr_accessor :wire_id, :runtime_page
-
-    def initialize(type:, id: nil, **props)
-      @type = type.to_s.downcase
-      @id = (id || props.delete(:id) || "ctrl_#{self.class.generate_id}").to_s
-      @children = []
-      @handlers = {}
-      @wire_id = nil
-      @props = normalize_props(extract_handlers(preprocess_props(props)))
-    end
-
-    def on(event_name, &block)
-      name = normalized_event_name(event_name)
-      @handlers[name] = block
-      @props["on_#{name}"] = true
-      runtime_page&.update(self, "on_#{name}": true) if wire_id
-      self
-    end
-
-    def emit(event_name, event)
-      handler = @handlers[normalized_event_name(event_name)]
-      return false unless handler
-
-      handler.call(event)
-      true
-    end
-
-    def has_handler?(event_name)
-      @handlers.key?(normalized_event_name(event_name))
-    end
-
-    def to_patch
-      patch = {
-        "_c" => TYPE_MAP.fetch(type, type.split("_").map(&:capitalize).join),
-        "_i" => wire_id
-      }
-
-      internals = {}
-      internals["host_positioned"] = true if type == "stack"
-      internals["host_expanded"] = true if HOST_EXPANDED_TYPES.include?(type)
-      patch["_internals"] = internals unless internals.empty?
-
-      props.each { |k, v| patch[k] = serialize_value(v) }
-      patch["controls"] = children.map(&:to_patch) unless children.empty?
-      patch
-    end
-
-    private
-
-    class << self
-      def generate_id
-        if defined?(SecureRandom) && SecureRandom.respond_to?(:hex)
-          SecureRandom.hex(4)
-        else
-          format("%08x", rand(0..0xffff_ffff))
-        end
-      end
-    end
-
-    def serialize_value(value)
-      case value
-      when Control
-        value.to_patch
-      when Ruflet::IconData
-        value.value
-      when Array
-        value.map { |v| serialize_value(v) }
-      when Hash
-        value.transform_values { |v| serialize_value(v) }
-      else
-        value
-      end
-    end
-
-    def extract_handlers(input)
-      output = input.dup
-
-      EVENT_PROPS.each do |prop, event_name|
-        string_prop = prop.to_s
-        next unless output.key?(prop) || output.key?(string_prop)
-
-        handler = output.key?(prop) ? output.delete(prop) : output.delete(string_prop)
-        @handlers[event_name] = handler if handler.respond_to?(:call)
-        output["on_#{event_name}"] = true
-      end
-
-      output
-    end
-
-    def normalize_props(hash)
-      hash.each_with_object({}) do |(k, v), result|
-        key = k.to_s
-        mapped_key = key
-        value =
-          if v.is_a?(Symbol)
-            v.to_s
-          elsif v.is_a?(Ruflet::IconData)
-            v.value
-          else
-            v
-          end
-        value = normalize_icon_prop(mapped_key, value)
-        value = normalize_color_prop(mapped_key, value)
-
-        result[mapped_key] = value
-      end
-    end
-
-    def preprocess_props(props)
-      props
-    end
-
-    def normalize_color_prop(key, value)
-      return value unless value.is_a?(String)
-      return value.downcase if color_prop_key?(key)
-
-      value
-    end
-
-    def color_prop_key?(key)
-      key == "color" || key == "bgcolor" || key.end_with?("_color")
-    end
-
-    def normalize_icon_prop(key, value)
-      return value unless icon_prop_key?(key)
-      codepoint = resolve_icon_codepoint(value)
-      codepoint.nil? ? value : codepoint
-    end
-
-    def icon_prop_key?(key)
-      key == "icon" || key.end_with?("_icon")
-    end
-
-    def resolve_icon_codepoint(value)
-      return nil unless value.is_a?(Integer) || value.is_a?(Symbol) || value.is_a?(String)
-
-      codepoint = Ruflet::MaterialIconLookup.codepoint_for(value)
-      if codepoint.nil? || (value.is_a?(Integer) && codepoint == value)
-        cupertino = Ruflet::CupertinoIconLookup.codepoint_for(value)
-        codepoint = cupertino unless cupertino.nil?
-      end
-      codepoint
-    end
-
-    def normalized_event_name(event_name)
-      event_name.to_s.sub(/\Aon_/, "")
-    end
-  end
-end

data/lib/ruflet_ui/ruflet/dsl.rb

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "ui/control_methods"
-require_relative "ui/control_factory"
-
-module Ruflet
-  module DSL
-    DURATION_FACTORS_MS = {
-      days: 86_400_000.0,
-      hours: 3_600_000.0,
-      minutes: 60_000.0,
-      seconds: 1_000.0,
-      milliseconds: 1.0,
-      microseconds: 0.001
-    }.freeze
-
-    module_function
-
-    def _pending_app
-      @_pending_app ||= App.new(host: "0.0.0.0", port: 8550)
-    end
-
-    def _reset_pending_app!
-      @_pending_app = App.new(host: "0.0.0.0", port: 8550)
-    end
-
-    def app(host: "0.0.0.0", port: 8550, &block)
-      return App.new(host: host, port: port).tap { |a| a.instance_eval(&block) } if block
-
-      pending = _pending_app
-      pending.set_endpoint!(host: host, port: port)
-      _reset_pending_app!
-      pending
-    end
-
-    def page(**props, &block) = _pending_app.page(**props, &block)
-    def control(type, **props, &block) = _pending_app.control(type, **props, &block)
-    def widget(type, **props, &block) = _pending_app.widget(type, **props, &block)
-    def column(**props, &block) = _pending_app.column(**props, &block)
-    def center(**props, &block) = _pending_app.center(**props, &block)
-    def row(**props, &block) = _pending_app.row(**props, &block)
-    def stack(**props, &block) = _pending_app.stack(**props, &block)
-    def grid_view(**props, &block) = _pending_app.grid_view(**props, &block)
-    def gridview(**props, &block) = _pending_app.gridview(**props, &block)
-    def container(**props, &block) = _pending_app.container(**props, &block)
-    def gesture_detector(**props, &block) = _pending_app.gesture_detector(**props, &block)
-    def gesturedetector(**props, &block) = _pending_app.gesturedetector(**props, &block)
-    def draggable(**props, &block) = _pending_app.draggable(**props, &block)
-    def drag_target(**props, &block) = _pending_app.drag_target(**props, &block)
-    def dragtarget(**props, &block) = _pending_app.dragtarget(**props, &block)
-    def text(value = nil, **props) = _pending_app.text(value, **props)
-    def button(**props) = _pending_app.button(**props)
-    def elevated_button(**props) = _pending_app.elevated_button(**props)
-    def elevatedbutton(**props) = _pending_app.elevatedbutton(**props)
-    def text_field(**props) = _pending_app.text_field(**props)
-    def textfield(**props) = _pending_app.textfield(**props)
-    def icon(**props) = _pending_app.icon(**props)
-    def image(src = nil, **props) = _pending_app.image(src, **props)
-    def icon_button(**props) = _pending_app.icon_button(**props)
-    def iconbutton(**props) = _pending_app.iconbutton(**props)
-    def app_bar(**props) = _pending_app.app_bar(**props)
-    def appbar(**props) = _pending_app.appbar(**props)
-    def clipboard(**props) = _pending_app.clipboard(**props)
-    def text_button(**props) = _pending_app.text_button(**props)
-    def textbutton(**props) = _pending_app.textbutton(**props)
-    def filled_button(**props) = _pending_app.filled_button(**props)
-    def filledbutton(**props) = _pending_app.filledbutton(**props)
-    def checkbox(**props) = _pending_app.checkbox(**props)
-    def radio(**props) = _pending_app.radio(**props)
-    def radio_group(**props) = _pending_app.radio_group(**props)
-    def radiogroup(**props) = _pending_app.radiogroup(**props)
-    def alert_dialog(**props) = _pending_app.alert_dialog(**props)
-    def alertdialog(**props) = _pending_app.alertdialog(**props)
-    def snack_bar(**props) = _pending_app.snack_bar(**props)
-    def snackbar(**props) = _pending_app.snackbar(**props)
-    def bottom_sheet(**props) = _pending_app.bottom_sheet(**props)
-    def bottomsheet(**props) = _pending_app.bottomsheet(**props)
-    def markdown(value = nil, **props) = _pending_app.markdown(value, **props)
-    def floating_action_button(**props) = _pending_app.floating_action_button(**props)
-    def floatingactionbutton(**props) = _pending_app.floatingactionbutton(**props)
-    def tabs(**props, &block) = _pending_app.tabs(**props, &block)
-    def tab(**props, &block) = _pending_app.tab(**props, &block)
-    def tab_bar(**props, &block) = _pending_app.tab_bar(**props, &block)
-    def tabbar(**props, &block) = _pending_app.tabbar(**props, &block)
-    def tab_bar_view(**props, &block) = _pending_app.tab_bar_view(**props, &block)
-    def tabbarview(**props, &block) = _pending_app.tabbarview(**props, &block)
-    def navigation_bar(**props, &block) = _pending_app.navigation_bar(**props, &block)
-    def navigationbar(**props, &block) = _pending_app.navigationbar(**props, &block)
-    def navigation_bar_destination(**props, &block) = _pending_app.navigation_bar_destination(**props, &block)
-    def navigationbardestination(**props, &block) = _pending_app.navigationbardestination(**props, &block)
-    def fab(content = nil, **props) = _pending_app.fab(content, **props)
-    def cupertino_button(**props) = _pending_app.cupertino_button(**props)
-    def cupertinobutton(**props) = _pending_app.cupertinobutton(**props)
-    def cupertino_filled_button(**props) = _pending_app.cupertino_filled_button(**props)
-    def cupertinofilledbutton(**props) = _pending_app.cupertinofilledbutton(**props)
-    def cupertino_text_field(**props) = _pending_app.cupertino_text_field(**props)
-    def cupertinotextfield(**props) = _pending_app.cupertinotextfield(**props)
-    def cupertino_switch(**props) = _pending_app.cupertino_switch(**props)
-    def cupertinoswitch(**props) = _pending_app.cupertinoswitch(**props)
-    def cupertino_slider(**props) = _pending_app.cupertino_slider(**props)
-    def cupertinoslider(**props) = _pending_app.cupertinoslider(**props)
-    def cupertino_alert_dialog(**props) = _pending_app.cupertino_alert_dialog(**props)
-    def cupertinoalertdialog(**props) = _pending_app.cupertinoalertdialog(**props)
-    def cupertino_action_sheet(**props) = _pending_app.cupertino_action_sheet(**props)
-    def cupertinoactionsheet(**props) = _pending_app.cupertinoactionsheet(**props)
-    def cupertino_dialog_action(**props) = _pending_app.cupertino_dialog_action(**props)
-    def cupertinodialogaction(**props) = _pending_app.cupertinodialogaction(**props)
-    def cupertino_navigation_bar(**props) = _pending_app.cupertino_navigation_bar(**props)
-    def cupertinonavigationbar(**props) = _pending_app.cupertinonavigationbar(**props)
-    def duration(**parts) = duration_in_milliseconds(parts)
-
-    class App
-      include UI::ControlMethods
-
-      attr_reader :page_props, :host, :port
-
-      def initialize(host:, port:)
-        @host = host
-        @port = port
-        @roots = []
-        @stack = []
-        @page_props = { "route" => "/" }
-        @seq = 0
-      end
-
-      def set_endpoint!(host:, port:)
-        @host = host
-        @port = port
-      end
-
-      def page(**props, &block)
-        @page_props.merge!(normalize_props(props))
-        instance_eval(&block) if block
-        self
-      end
-
-      def widget(type, **props, &block)
-        control(type.to_s, **props, &block)
-      end
-
-      def control(type, **props, &block)
-        mapped_props = props.dup
-        prop_children = extract_children_prop(mapped_props)
-
-        id = mapped_props.delete(:id)&.to_s || next_id(type)
-        c = Ruflet::UI::ControlFactory.build(type.to_s, id: id, **normalize_props(mapped_props))
-        attach(c)
-
-        if block
-          @stack.push(c)
-          instance_eval(&block)
-          @stack.pop
-        end
-
-        if prop_children
-          Array(prop_children).each { |child| c.children << child if child.is_a?(Ruflet::Control) }
-        end
-
-        c
-      end
-
-      def duration(**parts)
-        DSL.duration(**parts)
-      end
-
-      def run
-        app_roots = @roots
-        page_props = @page_props.dup
-
-        Ruflet::Server.new(host: host, port: port) do |runtime_page|
-          runtime_page.set_view_props(page_props)
-          runtime_page.add(*app_roots)
-        end.start
-      end
-
-      private
-
-      def build_widget(type, **props, &block) = control(type.to_s, **props, &block)
-
-      def attach(control)
-        if @stack.empty?
-          @roots << control
-        else
-          @stack.last.children << control
-        end
-      end
-
-      def normalize_props(hash)
-        hash.transform_keys(&:to_s).transform_values { |v| v.is_a?(Symbol) ? v.to_s : v }
-      end
-
-      def extract_children_prop(props)
-        props.delete(:children) ||
-          props.delete("children") ||
-          props.delete(:controls) ||
-          props.delete("controls")
-      end
-
-      def next_id(type)
-        @seq += 1
-        "#{type}_#{@seq}"
-      end
-
-      def duration_in_milliseconds(parts)
-        DSL.send(:duration_in_milliseconds, parts)
-      end
-
-    end
-
-    def duration_in_milliseconds(parts)
-      return 0 if parts.nil? || parts.empty?
-
-      DURATION_FACTORS_MS.reduce(0.0) do |sum, (key, factor)|
-        sum + read_duration_part(parts, key) * factor
-      end.round
-    end
-
-    def read_duration_part(parts, key)
-      raw = parts[key] || parts[key.to_s]
-      return 0.0 if raw.nil?
-      return raw.to_f if raw.is_a?(Numeric)
-      return raw.to_f if raw.is_a?(String) && raw.match?(/\A-?\d+(\.\d+)?\z/)
-
-      0.0
-    end
-  end
-end

data/lib/ruflet_ui/ruflet/event.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Ruflet
-  class Event
-    attr_reader :name, :target, :raw_data, :data, :page, :control
-
-    def initialize(name:, target:, raw_data:, page:, control:)
-      @name = name
-      @target = target
-      @raw_data = raw_data
-      @data = parse_data(raw_data)
-      @page = page
-      @control = control
-    end
-
-    private
-
-    def parse_data(raw)
-      return raw unless raw.is_a?(String)
-
-      JSON.parse(raw)
-    rescue JSON::ParserError
-      raw
-    end
-  end
-end