precise 0.1.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: de5da64054f1063eb0129a6aa14d03bc457ba1cdc68d9748618210e0c414f001
+  data.tar.gz: 738931cb458919672e14d9af523e18bfc9aecbde2b3efecefc4b85daa0e44446
+SHA512:
+  metadata.gz: 7d6b2d48809192ad96abcc2401feb6598fdaed2a30f039b2d0f0da13fd98d9ac76b4b6233fbaf1e17e2fe4825c1530e97a692f0d9332380d67f0dbb22d295f9b
+  data.tar.gz: 896f8c9cf2f58415d623e26ec69491f5e697166057faa7b5a692c127a227dd73999ab96c0e40e2bb4f267bb7441cba78a62e669ddb71e4ec5f3f2603bff1fabf

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# this gem's dependencies are specified in precise.gemspec
+gemspec
+# below are development dependencies only
+gem 'rake'
+gem 'minitest'
+gem 'standard'
+gem 'pry'

data/Gemfile.lock

@@ -0,0 +1,64 @@
+PATH
+  remote: .
+  specs:
+    precise (0.1.8)
+      progressbar
+      slop
+      tiny_color
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    coderay (1.1.3)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    method_source (1.0.0)
+    minitest (5.18.0)
+    parallel (1.22.1)
+    parser (3.2.1.1)
+      ast (~> 2.4.1)
+    progressbar (1.13.0)
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.7.0)
+    rexml (3.2.5)
+    rubocop (1.44.1)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.24.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.27.0)
+      parser (>= 3.2.1.0)
+    rubocop-performance (1.15.2)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.13.0)
+    slop (4.10.1)
+    standard (1.24.3)
+      language_server-protocol (~> 3.17.0.2)
+      rubocop (= 1.44.1)
+      rubocop-performance (= 1.15.2)
+    tiny_color (1.2.2)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  minitest
+  precise!
+  pry
+  rake
+  standard
+
+BUNDLED WITH
+   2.4.1

data/LICENSE.md

@@ -0,0 +1,163 @@
+GNU Lesser General Public License
+=================================
+
+_Version 3, 29 June 2007_  
+_Copyright © 2007 Free Software Foundation, Inc. &lt;<http://fsf.org/>&gt;_
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+
+This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+### 0. Additional Definitions
+
+As used herein, “this License” refers to version 3 of the GNU Lesser
+General Public License, and the “GNU GPL” refers to version 3 of the GNU
+General Public License.
+
+“The Library” refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+An “Application” is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+A “Combined Work” is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the “Linked
+Version”.
+
+The “Minimal Corresponding Source” for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The “Corresponding Application Code” for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+### 1. Exception to Section 3 of the GNU GPL
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+### 2. Conveying Modified Versions
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+* **a)** under this License, provided that you make a good faith effort to
+ensure that, in the event an Application does not supply the
+function or data, the facility still operates, and performs
+whatever part of its purpose remains meaningful, or
+
+* **b)** under the GNU GPL, with none of the additional permissions of
+this License applicable to that copy.
+
+### 3. Object Code Incorporating Material from Library Header Files
+
+The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+* **a)** Give prominent notice with each copy of the object code that the
+Library is used in it and that the Library and its use are
+covered by this License.
+* **b)** Accompany the object code with a copy of the GNU GPL and this license
+document.
+
+### 4. Combined Works
+
+You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+* **a)** Give prominent notice with each copy of the Combined Work that
+the Library is used in it and that the Library and its use are
+covered by this License.
+
+* **b)** Accompany the Combined Work with a copy of the GNU GPL and this license
+document.
+
+* **c)** For a Combined Work that displays copyright notices during
+execution, include the copyright notice for the Library among
+these notices, as well as a reference directing the user to the
+copies of the GNU GPL and this license document.
+
+* **d)** Do one of the following:
+    - **0)** Convey the Minimal Corresponding Source under the terms of this
+License, and the Corresponding Application Code in a form
+suitable for, and under terms that permit, the user to
+recombine or relink the Application with a modified version of
+the Linked Version to produce a modified Combined Work, in the
+manner specified by section 6 of the GNU GPL for conveying
+Corresponding Source.
+    - **1)** Use a suitable shared library mechanism for linking with the
+Library.  A suitable mechanism is one that **(a)** uses at run time
+a copy of the Library already present on the user's computer
+system, and **(b)** will operate properly with a modified version
+of the Library that is interface-compatible with the Linked
+Version.
+
+* **e)** Provide Installation Information, but only if you would otherwise
+be required to provide such information under section 6 of the
+GNU GPL, and only to the extent that such information is
+necessary to install and execute a modified version of the
+Combined Work produced by recombining or relinking the
+Application with a modified version of the Linked Version. (If
+you use option **4d0**, the Installation Information must accompany
+the Minimal Corresponding Source and Corresponding Application
+Code. If you use option **4d1**, you must provide the Installation
+Information in the manner specified by section 6 of the GNU GPL
+for conveying Corresponding Source.)
+
+### 5. Combined Libraries
+
+You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+* **a)** Accompany the combined library with a copy of the same work based
+on the Library, uncombined with any other library facilities,
+conveyed under the terms of this License.
+* **b)** Give prominent notice with the combined library that part of it
+is a work based on the Library, and explaining where to find the
+accompanying uncombined form of the same work.
+
+### 6. Revised Versions of the GNU Lesser General Public License
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License “or any later version”
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -0,0 +1,41 @@
+## Command line usage
+
+Install the gem and see the help message by executing:
+
+    $ gem install precise
+    $ precise -h
+
+Arabicise a string of Romanisation:
+
+    $ precise -T 'bi-smi llāhi al-raḥmani al-raḥīm' # -T removes Tashkeel
+
+Romanise a string of Arabic (experimental):
+
+    $ precise 'بسم  الله الرحمن الرحيم' # (not able to infer Tashkeel!)
+
+## Usage inside of another application
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add precise
+    $ bundle install
+
+You can then access the API like so:
+
+```ruby
+require 'precise'
+Precise::Transcription.reverse 'bi-smi llāhi al-raḥmani al-raḥīm'
+Precise::Transcription.transcribe 'ﺐﺴﻣ  ﺎﻠﻠﻫ ﺎﻟﺮﺤﻤﻧ ﺎﻟﺮﺤﻴﻣ'
+```
+
+## Development
+
+After checking out the repository, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+Issues and PRs are welcome!
+
+## Funding
+
+This Gem was developed within the long-term research project [Bibliotheca Arabica](http://www.bibliotheca-arabica.de) hosted at the Saxon Academy of the Sciences and Humanities in Leipzig, Germany. _Bibliotheca Arabica_ is part of the [German Academies’ Programme](https://www.akademienunion.de/en/research/the-academies-programme) and funded by the Federal Republic of Germany and the Free State of Saxony.

data/Rakefile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'bundler'
+Bundler.require
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
+desc 'increase minor version number by one'
+task :bump do
+  current = Precise::VERSION
+  new = current.split('.')
+  new[-1] = (new[-1].to_i+1).to_s
+  new = new.join('.')
+  version_file = 'lib/precise/version.rb'
+  File.write(version_file, File.read(version_file).gsub(current, new))
+end
+
+task :default do; system 'rake -T'; end

data/TODO.md

@@ -0,0 +1,42 @@
+Refactor to follow the following pattern:
+
+```ruby
+
+# short, romanised root <=> word list for learners: https://wahiduddin.net/words/arabic_glossary.htm
+# commercial root <=> word dict: http://www.arabicroot.com/Home/Introduction
+# possibly a good idea to OCR wehr 5 and make a dict from that?
+
+def arabic_roots(opts); ['ʿwl','msʾ'].reject{|r| !r.include? opts[:with_letter]}.compact; end # 
+
+# 2005: http://jeffcoombs.com/isri/Taghva2005b.pdf
+# 2006: NN-based: https://ieeexplore.ieee.org/document/4115547
+# 2007: https://ieeexplore.ieee.org/document/4230974/
+# 2014: https://journals.sagepub.com/doi/abs/10.1177/0165551514526348?journalCode=jisb
+# 2016: https://www.sciencedirect.com/science/article/pii/S1319157815001342
+# 2015: https://www.sciencedirect.com/science/article/pii/S1319157815000166
+# metastudy (also 2015): https://www.sciencedirect.com/science/article/pii/S1319157815000166
+# 2017: https://www.accentsjournals.org/PaperDirectory/Journal/IJACR/2018/3/3.pdf
+# anything newer???
+# some of the above testable at: http://arabic.emi.ac.ma:8080/SafarWeb/faces/safar/morphology/stemmer.xhtml
+
+def extract_root(word); {'ʿāʾila':'ʿwl','masāʾikà':'msʾ'}[word.to_sym]; end
+
+# with the above two in place:
+
+arabic = %w[ʿāʾila masāʾikà].map{|s|
+  words = s.split ' '
+  words.map{|w|
+    w.gsub! /āʾi/, arabic_roots(with_letter: 'ʾ').include?(extract_root(w)) ? 'āSTANDALONE_HAMZAi' : 'āYA_AS_HAMZA_CARRIERi'
+    [
+      {'YA_AS_HAMZA_CARRIER':'ﺉ', 'STANDALONE_HAMZA':'ﺀ'},
+      {'ʿ':'ﻉ', 'ā':'ﺍ', 'i':'ِ◌', 'l':'ﻝ', 'a':'َ◌', 'm':'ﻡ', 's':'ﺱ', 'k':'ﻙ', 'à':'َ◌'}
+    ].each{|list| list.each{|k,v| w.gsub! k.to_s, v}}
+    w.gsub! /◌$/, 'ﺓ'
+  }
+  words.join(' ').gsub('◌','')
+}
+
+# use actual tests from current code instead; also generate more from existing known-good data!
+
+tests = (arabic == ["ﻉﺎﺌِﻟَﺓ", "ﻢَﺳﺍﺀِﻙَﺓ"])
+```

data/exe/precise

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+f = File.basename(__FILE__, '.rb')
+if __FILE__.match(/exe\/#{f}$/) 
+  require_relative "../lib/#{f}"
+else
+  require f
+end
+
+Precise::CLI.start

data/lib/precise/core_extensions.rb

@@ -0,0 +1,24 @@
+module CoreExtensions
+  refine String do
+    def precise_titlecase
+      s = chars
+      s.map.with_index{|c,i|
+        !%w[a i u].include?(s[0]) && ((i==0 && self[0..1] != 'al') || (i==1 && %w[ʾ ʿ].include?(s[0]))) ? 
+          c.upcase :
+          c
+      }.join
+    end
+  end
+
+  refine Array do
+    def each_utf8_encode
+      map{|e| e.to_s.encode('utf-8')}
+    end
+  end
+
+  refine Hash do
+    def keys_and_values_to_s
+      map{|k,v| [k.to_s, v.class == Array ? v.map{|e| e.to_s} : v.to_s]}.to_h
+    end
+  end
+end

data/lib/precise/debugging.rb

@@ -0,0 +1 @@
+unless self.respond_to?(:dbg); $dbg = 0; def dbg str; puts str if $dbg > 0; end; end

data/lib/precise/error_classes.rb

@@ -0,0 +1,19 @@
+module Precise
+  class Error < StandardError; end
+
+  class TranscriptionError < StandardError
+    def initialize(msg="unable to transcribe input string", exception_type=:untranscribable)
+      @exception_type = exception_type
+      super(msg)
+    end
+    attr_reader :exception_type
+  end
+
+  class NotATranscriptionError < StandardError
+    def initialize(msg="input string is not (entirely) a romanisation of Arabic", exception_type=:untranscribable)
+      @exception_type = exception_type
+      super(msg)
+    end
+    attr_reader :exception_type
+  end
+end

data/lib/precise/transcription.rb

@@ -0,0 +1,11 @@
+module Precise
+  class Transcription
+    def initialize(opts = {})
+      default_options = {punctuation: true, verbosity: 0}
+      @opts = default_options.merge(opts)
+      @opts[:verbosity] += 2 if @opts.delete(:verbose) == true
+      $dbg += @opts[:verbosity]
+      @out_chunks = []
+    end
+  end
+end

data/lib/precise/transcription_a2r.rb

@@ -0,0 +1,123 @@
+module Precise
+  
+  using CoreExtensions # the more generic ones
+
+  class Transcription    
+    def transcription
+      @out_chunks
+        .map{|c| c
+          .gsub(/^m$/, 'mīlādī')
+          .gsub(/^h$/, 'hijrī')
+          .gsub(/^wāltī$/, 'wa-l-lātī')
+          .gsub(/^wālḏī$/, 'wa-l-lāḏī')
+          .gsub(/^hy$/, 'hiya')
+          .gsub(/^ʿlá$/, 'ʿalá')
+          .gsub(/^mn$/, 'min')
+          .gsub(/^yd$/, 'yad')
+          .gsub(/^fy$/, 'fī')
+          .gsub(/^lhā$/, 'lahā')}
+        .join(' ')
+        .gsub('؟','?')
+        .gsub('،',',')
+        .gsub(/\s+([[:punct:]]+)/,'\1')
+        .gsub(/(?!(\s+|^))\(\s+/, ' (')
+    end
+    
+    A2R = A2RTable = {
+      "ال": "al-",
+      "ء": "ʾ",
+      "آ": "ʾā",
+      "أ": "ʾa",
+      "أُ": "ʾu",
+      "إ": "ʾi",
+      "ا": "ā",
+      "ب": "b",
+      "ة": "a",
+      "ت": "t",
+      "ث": "ṯ",
+      "ج": "ǧ",
+      "ح": "ḥ",
+      "خ": "ḫ",
+      "د": "d",
+      "ذ": "ḏ",
+      "ر": "r",
+      "ز": "z",
+      "س": "s",
+      "ش": "š",
+      "ص": "ṣ",
+      "ض": "ḍ",
+      "ط": "ṭ",
+      "ظ": "ẓ",
+      "ع": "ʿ",
+      "غ": "ġ",
+      "ف": "f",
+      "ق": "q",
+      "ك": "k",
+      "ل": "l",
+      "م": "m",
+      "ن": "n",
+      "ه": "h",
+      "و": ["ū", "w"],
+      "ى": "á",
+      "ي": ["ī", "y"],
+      "َ": "a",
+      "ُ": "u",
+      "ِ": "i",
+      "پ": "p",
+      "چ": "č",
+      "ژ": "ž",
+      "گ": "g",
+      "٠": "0",
+      "١": "1",
+      "٢": "2",
+      "٣": "3",
+      "٤": "4",
+      "٥": "5",
+      "٦": "6",
+      "٧": "7",
+      "٨": "8",
+      "٩": "9",
+    }.map{|k,v| [k.to_s, v]}.to_h
+    SHADDA=' ّ'.strip
+
+    def transcribe(arabic)
+      non_word_rgx = /([\s\d[:punct:]]+)/
+      in_chunks = arabic.split non_word_rgx
+      in_chunks.each.with_index do |chunk,i|
+        word = chunk
+        (next) if chunk.strip.empty?
+        (@out_chunks << chunk.strip; next) if chunk.match? non_word_rgx
+        chars = chunk.chars
+        skip = 0
+        (@out_chunks << '')
+        chars.each.with_index do |ch,j|
+          (skip-=1; next) if skip>0
+          (@out_chunks[-1] << A2R['ال']; skip+=1; next) if j==0 && word.match?(/^ال/)
+          out_char = nil
+          # و and ي:
+          # first in array is a long vowel,
+          # second in array is a consonant
+          if A2R[ch].class==Array
+            if j==0 || j+1==word.length
+              (@out_chunks[-1] << A2R[ch][-1]; next)
+            else
+              out_char = A2R[ch][0]
+            end
+          else
+            out_char = A2R[ch]
+          end
+          (@out_chunks[-1] << A2R[chars[j-1]]) if ch == SHADDA
+          (@out_chunks[-1] << out_char; next) if out_char
+        end
+      end
+    end
+
+    def self.transcribe(arabic, opts={})
+      warn "Romanisation is incomplete.".yellow
+      warn "Consider adding short vowels by hand as needed.".yellow
+      obj = new(opts)
+      obj.transcribe(arabic)
+      return obj.transcription
+    end
+  end
+end

data/lib/precise/transcription_r2a.rb

@@ -0,0 +1,447 @@
+module Precise
+
+  using CoreExtensions # the more generic ones
+
+  module CoreExtensions # the ones specific to this module
+    refine String do
+      # default output is "with everything"
+      # so once something is set to false, it'll be removed
+      def apply_options(opts)
+        defaults = {punctuation: true, tashkeel: true, alif_variants: true}
+        opts = defaults.merge opts
+        s = self.dup
+
+        if !opts[:punctuation]
+          s = s.gsub(/[[:punct:]]+/,'')
+        end
+
+        if !opts[:tashkeel]
+          tashkeel = Precise::Transcription::Tashkeel
+          nonprintables = Precise::Transcription::Nonprintables
+          extraneous_chars = [tashkeel + nonprintables].join
+          s = s.gsub(/[#{extraneous_chars}]/,'')
+        end
+
+        if !opts[:alif_variants]
+          alif_variants = Precise::Transcription::AlifVariants
+          s = s.gsub(/[#{alif_variants}]/,'ا')
+        end
+
+        return s.strip
+      end
+    end
+  end
+
+  class Transcription
+    using Precise::CoreExtensions
+
+    # Ruby would have been fine with these in the file verbatim (on their own),
+    # alas, my editor's syntax highlighting can't cope, so doing it 1990s-style
+    Fatha, Kasra, Damma, Shadda = ["\u064e", "\u0650", "\u064f", "\u0651"].each_utf8_encode
+    # nonprintables
+    R2LM, L2RM, ZWNJ = ["\u200f", "\u200e", "\u200c"].each_utf8_encode
+    # typographic modifiers, ligatures, oft-used words
+    Tatweel, Allah = ["ـ", "الله‎"]
+    # the various forms of alif, ya and waw
+    AlifVariants = ['أ', 'إ', 'آ', 'ا', 'ٱ']
+    AlifHamzaAbove, AlifHamzaBelow, AlifMadda, Alif, AlifWasla = AlifVariants
+    YaHamzaAbove, Ya = ['ئ', 'ي']
+    WawHamzaAbove, Waw = ['ؤ', 'و']
+    # other character lists
+    Tashkeel = ("064B".to_i(16).."065B".to_i(16)).map{|dec| hex=("%04x" % dec); eval("char=\"\\u#{hex}\"; char")}
+    Nonprintables = [R2LM, L2RM]
+
+    R2ATables = {
+      # Adapted from the Transcription in the Brill PDF's "Note to the Indices":
+      # - a dash, depending on its position, denotes the start or end of the word
+      # - an array denotes the requirement for a choice to be made from context
+      # - any characters that are being replaced by DMG characters have been ommitted
+      common: {
+        ʾ:     :ء,
+        b:     :ب,
+        p:     :پ,
+        t:     :ت,
+        ḥ:     :ح,
+        d:     :د,
+        r:     :ر,
+        z:     :ز,
+        s:     :س,
+        ṣ:     :ص,
+        ḍ:     :ض,
+        ṭ:     :ط,
+        ẓ:     :ظ,
+        ʿ:     :ع,
+        f:     :ف,
+        q:     :ق,
+        k:     :ك,
+        g:     :گ,
+        l:     :ل,
+        m:     :م,
+        n:     :ن,
+        h:     :ه,
+        w:     :و,
+        y:     :ي,
+        ā:     :ا,
+        ū:     :و,
+        ī:     :ي,
+      },
+      vowels: {
+        a:     Fatha,
+        à:     Fatha, # at word-end only
+        u:     Damma,
+        i:     Kasra,
+      },
+      combos: {
+        aw:    :َو,
+        ay:    :َي
+      },
+      brockelmann: {
+        '-a':  :ة,  # "-" = at word-end
+        '-at': :ة,  # "-" = at word-end
+        'al-': :ال, # "-" = at word-start
+      },
+      dmg: {
+        ṯ:     :ث,
+        ǧ:     :ج,
+        č:     :چ,
+        ḫ:     :خ,
+        ḏ:     :ذ,
+        ž:     :ژ,
+        š:     :ش,
+        ġ:     :غ
+      },
+      uppercase: {
+        A:     :أَ,
+        I:     :إِ,
+        U:     :أُ,
+        Y:     :ي
+      },
+      farsi: {
+        v:     :و, # always? what, e.g. about "Divbandi"?
+        e:     [:ه, Fatha] # word-end, mid-word
+      },
+      turkic: {
+        ö:     :و,
+        ü:     Damma, # ???
+        ı:     Kasra, # ???
+        E:     :ا
+      },
+      indic: {
+        ō:    :و # things like "Bh" => "بْ" would go here, too
+      },
+      romanic: {
+        c:    :ث, # or should this rather be a س?
+        o:    :و,
+        Ė:    :إي,
+        x:    :كس
+      },
+      semitic: {
+        ē:    :ﺍ # is that always so?
+      },
+      finnic: {
+        ä:    Fatha # in e.g. Mänglī
+      },
+      precise: {
+        á:    :ى,
+        Ā:    :آ, # don't add 'ʾĀ' here - it is considered an error in the input!
+        'ʾā': :آ # same but lowercase - alif madda in the middle of the word
+      }
+    }
+
+    PostR2AWordReplacements = {
+      /^(.*)لّاه/ => '\1 الله', # names ending in "allah"
+      /(ب\.|إبن|إِبن)/ => 'بن', # "son of"
+      /أَبي/ => 'أبي', # "father of" (gen.)
+      /أَبو/ => 'أبو', # "father of" (nom.)
+      /بَكر/ => 'بكر', # the name "bakr"
+      /عَلي/ => 'علي', # the name "ali"
+      /عَبد/ => 'عبد', # the name-part "abd"
+      /افندي/ => 'افندی' # ottoman/turkish effendi
+      # /([یي]زاده$)/ => ZWNJ+'ی'+ZWNJ+'زاده', # names ending in "-azade" # removed at DK's request
+    }
+
+    PostR2AContextReplacements = {
+      /((^|\.\s+)بن(\s+))/ => 'ابن\3', # exception: son-of in beginning of sentence
+      /(تِ|تُ|تَ)(\s+)/ => 'ة ', # this'll lose the case ending, but that's for the better
+      /داوود/ => 'داود' # not sure if this might actually hold true for all ...wū...?
+    }
+
+    PunctSepRgx = /[ \.\-\(\)\?\&=,;:]/
+      
+    R2A = R2ATables.values.inject(:merge) # just one level is enough now
+                   .keys_and_values_to_s  # more convenient to work with
+
+    SunLetters = %w[t ṯ d ḏ r z s š ṣ ḍ ṭ ẓ l n]
+    RomanizedShortVowels = %w[a i u]
+    RomanizedLongVowels = %w[ā ū ī]
+    # "a" here because of ta'marbouta, "á" because of alif maqsoura, "ā" because of word-final alif mamdouda
+    RomanizedConsonantals = SunLetters + %w[m l k q f ġ ʿ ḫ ḥ h ǧ b ʾ a á]
+    ArabicScriptVowels = %w[ا ي و]
+    ArabicScriptConsonants = %w[ا ب ت ث ج ح خ س ش ص ض ط ظ ع غ ف ق ك ل م ن ه ي ئ ة ى أ إ ؤ ئ آ]
+      
+    LatinChars = R2A.map{|l,a| l unless l.size != 1}.compact
+    TranslitChars_lowercase = 'ʾʿḏḥṣḍṭẓāūīṯǧčḫžšġōĖēáäüöü'
+    TranslitChars = (TranslitChars_lowercase + TranslitChars_lowercase.upcase).chars.uniq.join
+
+    def this_word(str, idx)
+      str[0...idx][/\S*\z/] + (str[idx..-1][/\A[#{TranslitChars}\w]+/] || '')
+    end
+
+    def this_word_and_the_next(str, idx)
+      # first part: from beginning of string to index position, get all non-whitespace characters
+      # second part: from index position to end of string,
+      #              get all characters belonging to the word which the index position character belongs to,
+      #              as well as the next word if any
+      if str.match?(/\s+/)
+        str[0...idx][/\S*\z/] + (str[idx..-1][/\A[#{@translit_chars}\w]+\s+[#{@translit_chars}\w]+/i] || '')
+      else
+        str
+      end
+    end
+
+    def hamza_before_following(ch, pch, first_letter_of_word = false)
+      if first_letter_of_word
+        case ch.to_sym
+          when :a, :u then AlifHamzaAbove
+          when :i then AlifHamzaBelow
+          when :ā then AlifMadda
+          when :ī then "#{YaHamzaAbove}#{R2A[ch]}"
+          when :ū then "#{WawHamzaAbove}#{R2A[ch]}"
+        end
+      else
+        if %w[y ī].include? pch
+          # also take into account what PRECEDED the hamza - that might take precedence!
+          case ch.to_sym
+            when :a then YaHamzaAbove
+            when :i then YaHamzaAbove
+            when :u then WawHamzaAbove
+            when :ī then "#{YaHamzaAbove}#{R2A[ch]}"
+            when :ū then "#{WawHamzaAbove}#{R2A[ch]}"
+          end
+        else
+          case ch.to_sym
+            when :a then AlifHamzaAbove
+            when :i then YaHamzaAbove
+            when :u then
+              pch == 'ū' ? R2A['ʾ'] : WawHamzaAbove
+            when :ī then "#{YaHamzaAbove}#{R2A[ch]}"
+            when :ū then "#{WawHamzaAbove}#{R2A[ch]}"
+          end
+        end
+      end
+    end
+
+    def hamza_after_preceding(ch, first_letter_of_word = false)
+      if first_letter_of_word
+        case ch.to_sym
+          when :a then AlifHamzaAbove
+          when :u then R2A['ā']+Damma+WawHamzaAbove
+          when :i then R2A['ā']+YaHamzaAbove
+        end
+      else
+        case ch.to_sym
+          when :a then AlifHamzaAbove
+          when :i then YaHamzaAbove
+          when :u then WawHamzaAbove
+          when :ī then YaHamzaAbove
+        end
+      end
+    end
+
+    def alif_for_word_initial_kasra(word)
+      # a,i,u = that specific short vowel
+      # c = any consonantal
+      # s = any short vowel
+      # l = any long vowel
+      patterns = [
+        'iCClC',
+        'iCCiCClC',
+        'iClCC'
+      ]
+      # pp word
+      shorts = RomanizedShortVowels
+      longs = RomanizedLongVowels
+      consonants = RomanizedConsonantals
+      alif = Alif
+      patterns.each do |p|
+        # puts "> #{p}"
+        next unless word.size == p.size
+        match = true
+        word.chars.each_with_index do |c,i|
+          case p[i]
+            when 'C' then match = false unless consonants.include?(c)
+            when 's' then match = false unless shorts.include?(c)
+            when 'l' then match = false unless longs.include?(c)
+          else
+            match = false unless c == p[i]
+          end
+          # puts "after #{c}: #{match} (should have been #{p[i]})"
+        end
+        (match = false if word.downcase.match?(/^ist/)) # استـ introduces 
+        (alif = AlifHamzaBelow; break) if match
+      end; puts "\t\tfor #{word}: word-initial #{alif}".light_blue if $dbg > 1
+      alif
+    end
+
+    def sanitize(str)
+      # remove nonprintables such as the ZWNJ
+      # FIXME: the erroneous_chars replacement table should have already taken care of this?!
+      ["\u200c", "\u200f"].each{|ch| str.gsub! ch, ''}
+      # make letters following either ʿ or ʾ lowercase
+      lastc=''; str.chars.map{|c| c.downcase! if lastc.match?(/[ʿʾ]/); lastc=c}.join
+    end
+
+    # input: valid Precise string
+    #   example: (al-)ʿAbbādī Muḥammad Ibn Aḥmad Ibn Muḥammad al-Harawī
+    # output: Arabic string
+    #   example: العَبّادي مُحَمَّد بن أَحمَد بن مُحَمَّد الهَرَوي
+    def reverse(romanized)
+      raise Precise::NotATranscriptionError if romanized.nil?
+
+      # sure, it's called "Precise", but it should still be 
+      # as tolerant as possible in what it accepts as input...
+      romanized = sanitize(romanized)
+      arabic = '' # we start with an empty string and go character by character
+
+      puts "- (#{romanized.size}) [#{romanized}]".light_green if $dbg > 1
+
+      # next, turn strings into character arrays
+      romanized = romanized.chars
+      arabic = arabic.chars
+      # to be able to merge 2 romanized characters into 1 arabic character
+      skip = false
+      # print string like so: ʿ·A·b·b·ā·d·ī· ·M·u·ḥ·a·m·m·a·d· ·I·b·n· ·A·ḥ·m·a·d· ·I·b·n· ...
+      puts "- (#{romanized.size}) [#{romanized.join('·')}]".light_green if $dbg > 1
+
+      # loop over the romanized character array, filling the arabic one up as we go
+      romanized.each_with_index do |ch,i|
+        # a little bit of context
+         pch = i == 0 ? nil : romanized[i-1]
+         fch = romanized[i+1]
+        ffch = romanized[i+2]
+
+        # multi-letter skip-aheads
+        if skip
+          dbg "\t\tskipping #{ch}"
+          if !(pch=='a' && fch=='-') # we're in the middle of "al-" (word-start)
+            skip=false; end; next; end
+
+        # symbols to remove from input
+        (dbg "\tskipping unprintable symbol"; next) if [ZWNJ].include?(ch)
+
+        # deal with alif madda before "normal" hamza rules follow
+        if ("#{ch}#{fch}".match?(/ʾā/) || "#{pch}#{ch}".match?(/^Ā/))
+          (dbg "\talif madda #{R2A['ʾā']}"; arabic << R2A['ʾā']; skip=true; next); end
+
+        # hamza followed by a short or long vowel
+        if ch == 'ʾ' && %w[a i u ā ī ū].include?(fch.to_s.downcase)
+          is_first_letter_of_word = (pch.nil? || pch.match(/\s+/))
+          (dbg "\t#{ch} with following #{fch}";
+           arabic << hamza_before_following(fch, pch, is_first_letter_of_word);
+           skip=true unless this_word(romanized.join, i).match?(/(a$|at($|\s))/)
+           next); end
+        # hamza preceded by a short vowel
+        # (beware of a possible alif madda (would be dealt with above, on the next round))
+        if fch.to_s == 'ʾ' && !ffch.to_s.match?(/[āĀ]/) && %w[a i u].include?(ch.downcase)
+          is_first_letter_of_word = (pch.nil? || pch.match(/\s+/))
+          (dbg "\t#{fch} carried on or following preceding #{ch}"
+           arabic << hamza_after_preceding(ch, is_first_letter_of_word); skip=true; next); end
+
+        # find the article "al", marked by having a dash appended to it
+        (dbg "\tarticle al- #{R2A['al-']}"; arabic << R2A['al-']; skip=true; next) if ("#{ch}#{fch}#{ffch}" == 'al-')
+
+        # unconditionally add spaces, dots and dashes to the output
+        (dbg "\tinitial only (#{pch}#{ch})"; arabic << ch; next) if ch=='.' && (fch.nil? || fch.match(/\s+/))
+        (dbg "\tnon-letter (#{ch})"; arabic << ch; next) if ch.match(PunctSepRgx) # white space or punctuation
+
+        # a word-initial "a" or "u" must always be preceded by "ʾ"; only "i" can possibly *not* have one
+
+        # deal with word-initial special cases
+        if pch.to_s.strip.empty? # either beginning of string or of word
+          if %w[a u].include?(ch)  
+            (dbg "\tprepending #{ch} with hamza"; arabic << R2A[ch.upcase]; next); end
+          if ch == 'i'
+            (dbg "\thamza-less alif?"
+             context = this_word(romanized.join, i)
+             arabic << alif_for_word_initial_kasra(context.split(/^w?al-/).last)
+             next); end; end
+
+        # perform tashdeed
+        (out=R2A[ch]+Shadda; dbg "\ttashdeed of #{ch} #{out}"; arabic << out; skip = true; next) if R2A[ch] && ch==fch
+
+        # should there be a ta'marbouta or not at the end of the word?
+        context1 = this_word(romanized.join,i)
+        context2 = this_word_and_the_next(romanized.join,i)
+        if context1 == context2 # single word
+          if (i == context1.length-2 && "#{ch}#{fch}".match?(/at$/)) \
+             || (i == context1.length-1 && "#{ch}#{fch}".match?(/a$/))
+             arabic << R2A['-at']+' '; skip=true; next
+          end
+        else # multiple words
+          if (i == context1.length-2 && "#{ch}#{fch}#{ffch}".match?(/at\s/))
+            arabic << R2A['-a']+' '; skip = true; next
+          elsif (i == context1.length-1 && "#{ch}#{fch}".match?(/a\s/))
+            arabic << R2A['-a']+' '; next
+          end
+        end
+
+        # letter ayn followed by uppercase vowel
+        if ch == 'ʿ'
+          (skip=true; ar=R2A[ch]) if %w[A I U].include?(fch)
+          case fch # ayn+following vowel at beginning of word
+            when 'A' then ar+=Fatha
+            when 'I' then ar+=Kasra
+            when 'U' then ar+=Damma; end; end
+        (dbg "\tayn+vowel #{ch}#{fch} #{ar}"; arabic << ar; next) if ar && ar.size==2
+
+        # long "a" at word-end: alif maqsoorah, otherwise normal alif
+        # "e" at word-end: letter hah, otherwise just a fatha
+        if R2A[ch].class == Array
+          choice = (fch.nil? || fch==' ') ? R2A[ch].first : R2A[ch].last
+          (dbg "\tcontextual #{ch} #{choice}"; arabic << choice; next); end
+
+        # exact match (pure transliteration, no transcription effort required)
+        (dbg "\tfrom table #{ch}→#{R2A[ch]}"; arabic << R2A[ch]; next) if R2A[ch]
+
+        # no luck yet; might be a regular uppercase letter
+        (dbg "\tuppercased #{ch} #{R2A[ch.downcase]}"; arabic << R2A[ch.downcase]; next) if R2A[ch.downcase]
+
+        # still no luck; last shot is punctuation
+        (dbg "\tinterpunctuation #{ch}"; arabic << ch; next) if ch.match?(/[[:punct:]]/)
+
+        # mark unknown characters as such; the philosophy here being that input to
+        # Precise should be pre-processed enough for this to never have to happen…
+        warn "Warning: character '#{ch}' is unknown to Precise and will be substituted by placeholder only".yellow
+        arabic << '�'
+      end
+
+      # character-array to word-array
+      arabic = arabic.compact.join.split
+      # العأَبّادي محمّد إِبن أَحمد إِبن محمّد للهروي (but with () around "al")
+      puts "- (#{arabic.join(' ').size-1}) [#{L2RM+arabic.join(' ')+L2RM}]".light_green if $dbg > 1
+
+      # dragnet replacement of special words, such as changing "ibn" into "bin"
+      2.times.each_with_index do |i|
+        puts "#{' '*6}(postprocessing round #{i+1})".light_green if $dbg > 1
+        PostR2AWordReplacements.each{|rgx,subst|
+          arabic.map!{|w|
+            puts "#{' '*8}word match: #{L2RM}#{rgx.inspect} #{L2RM}=> #{L2RM}'#{subst}'".green if (w.match(rgx) && $dbg > 1)
+            w.gsub(/-/, '') # dashes not needed anymore now
+             .gsub(rgx, subst)} }
+      end
+
+      # some rules apply only in the context of words, not letters
+      puts "- (#{arabic.join(' ').size-1}) [#{L2RM+arabic.join(' ')+L2RM}]".light_green if $dbg > 1
+      arabic = arabic.join(' ')
+      PostR2AContextReplacements.each{|rgx,subst|
+        puts "#{' '*8}context match: #{L2RM}#{rgx.inspect} #{L2RM}=> #{L2RM}'#{subst}'".green if (arabic.match(rgx) && $dbg > 1)
+        arabic.gsub!(rgx, subst) }
+
+      return arabic.apply_options(@opts)
+    end
+
+    def self.reverse(romanized, opts={})
+      new(opts).reverse(romanized)
+    end
+  end
+end

data/lib/precise/types_list.rb

@@ -0,0 +1,37 @@
+require 'fileutils'
+
+module Precise
+  using CoreExtensions
+
+  class TypesList
+    @@types = nil 
+
+    def initialize
+      resdir = File.join __dir__,'..','..','res'
+      FileUtils.mkdir_p resdir
+      typesfile = File.absolute_path(File.join resdir,'types.lst')
+      download(typesfile) unless File.exist? typesfile
+      @types ||= File.readlines typesfile, chomp: true
+    end
+
+    def download(path)
+      puts 'downloading types database (only needed once)...'
+      require 'net/http'
+      require 'open-uri'
+			require 'progressbar'
+      url = 'https://raw.githubusercontent.com/sixtyfive/arabic-types/main/types.lst'
+      data = URI.open(url)
+      IO.copy_stream data, path
+    end
+
+    def percentage_of_tokens_present(string)
+      words = string.split
+      n_present = words.map{|w| @types.include? w}.count(true)
+      100.0 / words.length * n_present
+    end
+
+    def self.percentage_of_tokens_present(string)
+      new.percentage_of_tokens_present(string)
+    end
+  end
+end

data/lib/precise/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Precise
+  VERSION = '0.1.8'
+end

data/lib/precise.rb

@@ -0,0 +1,67 @@
+require 'pp'
+require 'slop'
+require 'yaml'
+require 'tiny_color'
+
+deps = %w[version debugging error_classes core_extensions transcription transcription_r2a transcription_a2r types_list]
+deps.each{|d| require_relative File.join(__dir__,'..','lib','precise',d)}
+
+module Precise
+  class CLI
+    def initialize
+      opts = Slop::Options.new
+      opts.banner = "Usage: precise [options] <string(s)>\n"
+      opts.separator "    where options can be:\n"
+      alif_variants = Precise::Transcription::AlifVariants
+      opts.bool "-s", "--show-rules", "print the list of rules which are applied for transcription"
+      opts.bool "-c", "--confidence", "also print the percentage of output words appearing in a large corpus of Arabic"
+      opts.bool "-A", "--no-alif-variants", "all of #{alif_variants.join("، ")} will be merged into ا"
+      opts.bool "-T", "--no-tashkeel", "diacritics (and non printables, such as tatweel) will be removed from output"
+      opts.bool "-P", "--no-punctuation", "all punctuation characters will be discarded from output"
+      opts.bool "-v", "--verbose", "instruct the backend classes to output debugging and plausibility information"
+      opts.bool "-h", "--help", "display this message"
+      opts.separator "\n    Transcription direction is determined by presence of characters from the 'Arabic' Unicode block.\n" \
+        "    At present, Arabic-to-Roman transcription is only rudimentary."
+      opts = Slop::Parser.new(opts)
+
+      begin
+        @opts = opts.parse(ARGV)
+        usage if @opts[:help] || ARGV.size == 0
+        rules if @opts.to_h[:show_rules]
+      rescue
+        @opts = opts.parse([])
+        usage
+      end
+
+      options = {verbose: @opts[:verbose]}
+      options[:alif_variants] = false if @opts.to_h[:no_alif_variants]
+      options[:tashkeel] = false if @opts.to_h[:no_tashkeel]
+      options[:punctuation] = false if @opts.to_h[:no_punctuation]
+
+      instr = @opts.arguments.join(' ')
+      if instr.match?(/\p{Arabic}/)
+        outstr = Precise::Transcription.transcribe(instr.dup, options)
+      else
+        outstr = Precise::Transcription.reverse(instr.dup, options)
+        outstr += " (#{Precise::TypesList::percentage_of_tokens_present(outstr)}%)" if @opts[:confidence]
+      end
+      puts outstr.pretty_inspect.gsub(/(^"|"$)/, "").strip
+    end
+
+    def usage
+      warn @opts
+      exit
+    end
+
+    def rules
+      puts Precise::Transcription::R2ATables.map{|k,v| Hash[k.to_s,v.map{|kk,vv| Hash[kk.to_s,vv]}]}.to_yaml.gsub(/---\n/,'')
+      exit
+    end
+
+    def nopts
+      @opts.to_h.values.map { |o| o || nil }.compact.size
+    end
+
+    def self.start; new; end
+  end
+end

data/precise.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'lib/precise/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'precise'
+  spec.version = Precise::VERSION
+  spec.authors = ['J. R. Schmid']
+  spec.email = ['jrs+git@weitnahbei.de']
+
+  spec.summary = 'Arabic to DMG-like (but more precise) and back'
+  spec.description = 'Romanise Arabic script, arabicise romanisations of Arabic script back into Latin script '
+  spec.homepage = 'https://rubygems.org/gems/precise'
+  spec.required_ruby_version = '>= 2.7.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/sixtyfive/precise.git'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # dependencies
+
+  spec.add_dependency 'slop'
+  spec.add_dependency 'tiny_color'
+  spec.add_dependency 'progressbar'
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: precise
+version: !ruby/object:Gem::Version
+  version: 0.1.8
+platform: ruby
+authors:
+- J. R. Schmid
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tiny_color
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'Romanise Arabic script, arabicise romanisations of Arabic script back
+  into Latin script '
+email:
+- jrs+git@weitnahbei.de
+executables:
+- precise
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- TODO.md
+- exe/precise
+- lib/precise.rb
+- lib/precise/core_extensions.rb
+- lib/precise/debugging.rb
+- lib/precise/error_classes.rb
+- lib/precise/transcription.rb
+- lib/precise/transcription_a2r.rb
+- lib/precise/transcription_r2a.rb
+- lib/precise/types_list.rb
+- lib/precise/version.rb
+- precise.gemspec
+homepage: https://rubygems.org/gems/precise
+licenses: []
+metadata:
+  homepage_uri: https://rubygems.org/gems/precise
+  source_code_uri: https://github.com/sixtyfive/precise.git
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.25
+signing_key:
+specification_version: 4
+summary: Arabic to DMG-like (but more precise) and back
+test_files: []