"use strict";

(function($B){

var _b_ = $B.builtins

var from_unicode = {},

to_unicode = {}

function bytes_value(obj){

return $B.get_class(obj) === bytes ? obj : fast_bytes(obj.source)

}

// Conversion of byte-like objects (bytes, bytearray, memoryview, array.array...)

// into a list of bytes

// Make the function an attribute of $B, it is used in libs/_binascii.js

$B.to_bytes = function(obj){

var res

if($B.$isinstance(obj, [bytes, bytearray])){

res = obj.source

}else{

var ga = $B.$getattr(obj, "tobytes", null)

if(ga !== null){

res = $B.$call(ga).source

}else{

$B.RAISE(_b_.TypeError, "object doesn't support the buffer protocol")

}

}

return res

}

var ws_cars = []

var ws = '\r\n \t'

for(let i = 0, len = ws.length; i < len; i++){

ws_cars.push(ws.charCodeAt(i))

}

function invalid(other){

return ! $B.$isinstance(other, [bytes, bytearray])

}

var is_bytes_like = $B.is_bytes_like = function(obj){

return $B.$getattr(obj, '__buffer__', $B.NULL) !== $B.NULL

}

function get_list_from_bytes_like(obj){

var buf = $B.$call($B.$getattr(obj, '__buffer__'), 0)

if(! $B.exact_type(buf, _b_.memoryview)){

$B.RAISE(_b_.TypeError,

`__buffer__ should return memoryview, not ${$B.class_name(buf)}`

)

}

return _b_.memoryview.tp_funcs.tolist(buf)

}

function check_buffer(arg){

if(! is_bytes_like(arg)){

$B.RAISE(_b_.TypeError, "a bytes-like object is required, " +

"not '" + $B.class_name(arg) + "'")

}

}

function check_buffer_or_int(arg){

if(! $B.is_int(arg) && ! is_bytes_like(arg)){

$B.RAISE(_b_.TypeError,

`argument should be integer or bytes-like object, ` +

`not '${$B.class_name(sub)}'`

)

}

}

/* bytearray_iterator start */

$B.bytearray_iterator.tp_iter = function(self){

return self

}

$B.bytearray_iterator.tp_iternext = function*(self){

self.index++

if(self.index >= self.len){

return

}

yield self.obj.source[self.index]

}

var bytearray_iterator_funcs = $B.bytearray_iterator.tp_funcs = {}

bytearray_iterator_funcs.__length_hint__ = function(self){

return self.len

}

bytearray_iterator_funcs.__reduce__ = function(self){

return $B.fast_tuple([_b_.iter, $B.fast_tuple([self.obj]), 0])

}

bytearray_iterator_funcs.__setstate__ = function(self, value){

self.index = $B.PyNumber_Index(value) - 1

}

$B.bytearray_iterator.tp_methods = ["__length_hint__", "__reduce__", "__setstate__"]

/* bytearray_iterator end */

//bytearray() (built in class)

var bytearray = _b_.bytearray

function no_resizing(){

$B.RAISE(_b_.BufferError,

"Existing exports of data: object cannot be re-sized")

}

function self_arg(func_name, args){

var $ = $B.args(func_name, 1, {self: null}, args, null, null, null)

return $.self

}

function self_other_args(func_name, args){

var $ = $B.args(func_name, 2, {self: null, other: null}, args, null,

null, null)

return [$.self, $.other]

}

function main_type(obj){

// used in methods to get the result type

// the type of obj.upper() is bytearray if obj type is a subclass of

// bytearray

return $B.$isinstance(obj, _b_.bytearray) ? _b_.bytearray : _b_.bytes

}

function bytearray_delitem(self, arg){

if(self.exports){

if($B.$isinstance(arg, _b_.slice)){

var slice = _b_.slice.$conv_for_seq(arg, self.source.length)

if(slice.stop - slice.start > 0){

no_resizing()

}

}else{

no_resizing()

}

}

return $B.list_delitem(self.source, arg)

}

function capitalize(){

var self = self_arg('capitalize', arguments)

var src = self.source,

len = src.length,

buffer = src.slice()

if(buffer[0] > 96 && buffer[0] < 123){buffer[0] -= 32}

for(var i = 1; i < len; ++i){

if(buffer[i] > 64 && buffer[i] < 91){

buffer[i] += 32

}

}

return main_type(self).$factory(buffer)

}

function center(){

var $ = $B.args('center', 3, {self: null, width: null, fillbyte: null},

arguments, {fillbyte: bytes.$factory([32])}, null, null)

var diff = $.width - $.self.source.length

if(diff <= 0){

return bytes.$factory($.self.source)

}

var type = main_type(self)

var ljust = type.tp_funcs.ljust($.self, $.self.source.length + Math.floor(diff / 2),

$.fillbyte)

return type.tp_funcs.rjust(ljust, $.width, $.fillbyte)

}

function count(self){

var $ = $B.args('count', 4,

{self: null, sub: null, start: null, end: null},

arguments, {start: 0, end: -1}, null, null)

var self = $.self,

sub = $.sub,

start = $.start,

end = $.end

var nb = 0,

len = self.source.length

if(typeof sub == "number"){

if(sub < 0 || sub > 255){

$B.RAISE(_b_.ValueError, "byte must be in range(0, 256)")

}

for(var b of self.source){

if(b == sub){

nb++

}

}

return nb

}

check_buffer(sub)

var seq = get_list_from_bytes_like(sub)

var seq_len = seq.length

var le

for(var i = 0; i < len; i++){

var found = 1

for(var j = 0; j < seq_len; j++){

if(self.source[i + j] != seq[j]){

found = 0

break

}

}

nb += found

}

return nb

}

function decode(self){

var $ = $B.args("decode", 3, {self: null, encoding: null, errors: null},

arguments, {encoding: "utf-8", errors: "strict"}, null, null)

switch ($.errors) {

case 'strict':

case 'ignore':

case 'replace':

case 'surrogateescape':

case 'surrogatepass':

case 'xmlcharrefreplace':

case 'backslashreplace':

return decode($.self, $.encoding, $.errors)

default:

// raise error since errors variable is not valid

}

}

function endswith(){

var $ = $B.args('endswith', 4,

{self: null, suffix: null, start: null, end: null},

arguments, {start: -1, end: -1}, null, null)

var self = $.self,

suffix = $.suffix,

start = $.start,

end = $.end

if(is_bytes_like(suffix)){

var seq = get_list_from_bytes_like(suffix)

start = start == -1 ? 0 : start

end = end == -1 ? self.source.length : end

var res = true

var seq_len = seq.length

if(seq_len > end - start){

return false

}

for(let i = 0; i < seq_len && res; i++){

res = self.source[end - seq_len + i] == seq[i]

}

return res

}else if($B.is_tuple(suffix)){

for(let sub of suffix){

if(endswith(self, sub, start, end)){

return true

}

}

return false

}else{

$B.RAISE(_b_.TypeError, "endswith first arg must be bytes-like " +

"or a tuple of bytes-like, not " + $B.class_name($.suffix))

}

}

function expandtabs(){

var $ = $B.args('expandtabs', 2, {self: null, tabsize: null},

arguments, {tabsize: 8}, null, null)

var self = $.self,

tabsize = $.tabsize

var tab_spaces = []

for(let i = 0; i < tabsize; ++i){

tab_spaces.push(32)

}

var buffer = self.source.slice()

for(let i = 0; i < buffer.length; ++i){

if(buffer[i] === 9){

var nb_spaces = tabsize - i % tabsize

var tabs = new Array(nb_spaces)

tabs.fill(32)

buffer.splice.apply(buffer, [i, 1].concat(tabs))

}

}

return main_type(self).$factory(buffer)

}

function find(){

var func = this // 'find' or 'rfind'

var $ = $B.args(func, 4, {self: null, sub: null, start: null, end: null},

arguments,

{start: _b_.None, end: _b_.None}, null, null)

var self = $.self,

sub = $.sub,

start = $.start,

end = $.end

check_buffer_or_int(sub)

var seq

if($B.is_int(sub)){

seq = [$B.PyNumber_Index(sub)]

}else{

seq = get_list_from_bytes_like(sub)

}

var boundaries = _b_.slice.$conv_for_seq({start, stop: end, step: 1},

self.source.length)

start = boundaries.start

end = boundaries.stop

var seq_len = seq.length

if(func == 'find'){

for(var i = start; i < end - seq_len + 1; i++){

var found = true

for(var j = 0; j < seq_len; j++){

if(self.source[i + j] != seq[j]){

found = false

break

}

}

if(found){

return i

}

}

}else{ // rfind

for(var i = end - 1; i > start - seq_len; i--){

var found = true

for(var j = 0; j < seq_len; j++){

if(self.source[i + j] != seq[j]){

found = false

break

}

}

if(found){

return i

}

}

}

return -1

}

function fromhex(){

var $ = $B.args('fromhex', 2, {cls: null, string: null},

arguments, null, null, null)

var cls = $.cls,

string = $.string

string = string.replace(/\s/g, '')

var source = []

for(var i = 0; i < string.length; i += 2){

if(i + 2 > string.length){

$B.RAISE(_b_.ValueError, "non-hexadecimal number found " +

"in fromhex() arg")

}

source.push(_b_.int.$factory(string.substr(i, 2), 16))

}

return $B.$call(cls, source)

}

function hex(){

// Return a string which is hex representation of the instance

// The hexstring can include a separator every specified number of bytes

var $ = $B.args('hex', 3, {self:null, sep:null, bytes_per_sep:null},

arguments, {sep: "", bytes_per_sep: 1}, null, null)

var self = $.self,

sep = $.sep,

bytes_per_sep = $.bytes_per_sep,

res = "",

digits = "0123456789abcdef",

bps = bytes_per_sep,

jstart = bps,

len = self.source.length;

if(bytes_per_sep < 0){

bps = -bytes_per_sep;

jstart = bps

}else if(bytes_per_sep == 0){

sep = ''

}else{

jstart = len % bps

if(jstart == 0){

jstart = bps

}

}

for(var i = 0, j = jstart; i < len; i++){

var c = self.source[i]

if (j == 0) {

res += sep

j = bps

}

j--

res += digits[c >> 4]

res += digits[c & 0x0f]

}

return res

}

function isalnum(){

var self = self_arg('isalnum', arguments)

var src = self.source,

len = src.length,

res = len > 0

for(var i = 0; i < len && res; ++i){

res = (src[i] > 96 && src[i] < 123) || // Lowercase

(src[i] > 64 && src[i] < 91) || // Uppercase

(src[i] > 47 && src[i] < 58) // Digit

}

return res

}

function isalpha(){

var self = self_arg('isalpha', arguments)

var src = self.source,

len = src.length,

res = len > 0

for(var i = 0; i < len && res; ++i){

res = (src[i] > 96 && src[i] < 123) || (src[i] > 64 && src[i] < 91)

}

return res

}

function isascii(){

var self = self_arg('isascii', arguments)

for(var byte of self.source){

if(byte > 0x7F){

return false

}

}

return true

}

function isdigit(){

var self = self_arg('isdigit', arguments)

var src = self.source,

len = src.length,

res = len > 0

for(let i = 0; i < len && res; ++i){

res = src[i] > 47 && src[i] < 58

}

return res

}

function islower(){

var self = self_arg('islower', arguments)

var src = self.source,

len = src.length,

res = false

for(let i = 0; i < len; ++i){

// Check for at least 1 lowercase ascii character

res = res || (src[i] > 96 && src[i] < 123)

// Don't allow any uppercase ascii characters

if(src[i] > 64 && src[i] < 91){return false}

}

return res

}

function isspace(){

var self = self_arg('isspace', arguments)

var src = self.source,

len = src.length

for(let i = 0; i < len; ++i){

switch(src[i]){

case 9: // Horizontal tab

case 10: // Line feed

case 11: // Vertical tab

case 12: // Form feed

case 13: // Carriage return

case 32: // Space

break

default:

return false

}

}

return true

}

function istitle(){

var self = self_arg('istitle', arguments)

var src = self.source,

len = src.length,

current_char_is_letter = false,

prev_char_was_letter = false,

is_uppercase = false,

is_lowercase = false

for(var i = 0; i < len; ++i){

is_lowercase = src[i] > 96 && src[i] < 123

is_uppercase = src[i] > 64 && src[i] < 91

current_char_is_letter = is_lowercase || is_uppercase

if(current_char_is_letter &&

(prev_char_was_letter && is_uppercase) ||

(! prev_char_was_letter && is_lowercase)){

return false

}

prev_char_was_letter = current_char_is_letter

}

return true

}

function isupper(){

var self = self_arg('isupper', arguments)

var src = self.source,

len = src.length,

res = false

for(let i = 0; i < len; ++i){

// Check for at least 1 uppercase ascii character

res = res || (src[i] > 64 && src[i] < 91)

// Don't allow any lowercase ascii characters

if(src[i] > 96 && src[i] < 123){return false}

}

return res

}

function join(){

var $ns = $B.args('join', 2, {self: null, iterable: null},

arguments),

self = $ns['self'],

iterable = $ns['iterable']

var res = this.$factory(),

empty = true

for(var item of $B.make_js_iterator(iterable)){

if(empty){

empty = false

}else{

res = bytes.sq_concat(res, self)

}

res = bytes.sq_concat(res, item)

}

return res

}

function ljust(){

// "this" is bytearray or bytes

var $ = $B.args('ljust', 3, {self: null, width: null, fillbyte: null},

arguments, {fillbyte: bytes.$factory([32])})

var self = $.self,

width = $.width,

fillbyte = $.fillbyte

check_buffer(fillbyte)

var padding = [],

count = width - self.source.length

for(var i = 0; i < count; ++i){

padding.push(fillbyte.source[0])

}

return this.$factory(self.source.concat(padding))

}

function lower(self){

var _res = [],

pos = 0

for(var i = 0, len = self.source.length; i < len; i++){

if(self.source[i]){_res[pos++] = _lower(self.source[i])}

}

return this.$factory(_res)

}

function maketrans(){

var $ = $B.args('maketrans', 2, {from:null, to: null}, arguments)

var from = $.from,

to = $.to

var _t = []

to = $B.to_bytes(to)

// make 'default' translate table

for(let i = 0; i < 256; i++){

_t[i] = i

}

// make substitution in the translation table

for(let i = 0, len = from.source.length; i < len; i++){

var _ndx = from.source[i] //retrieve ascii code of char

_t[_ndx] = to[i]

}

// return the bytes object associated to the 256-elt list

return this.$factory(_t)

}

function strip(self, cars, lr){

if(cars === undefined){

cars = []

var ws = '\r\n \t'

for(let i = 0, len = ws.length; i < len; i++){

cars.push(ws.charCodeAt(i))

}

}else if($B.$isinstance(cars, bytes)){

cars = cars.source

}else{

$B.RAISE(_b_.TypeError, "Type str doesn't support the buffer API")

}

switch(lr){

case 'l':

for(var i = 0, len = self.source.length; i < len; i++){

if(cars.indexOf(self.source[i]) == -1){

break

}

}

return this.$factory(self.source.slice(i))

case 'r':

for(var i = self.source.length - 1; i >= 0; i--){

if(cars.indexOf(self.source[i]) == -1){

break

}

}

return this.$factory(self.source.slice(0, i + 1))

}

}

function nb_multiply(){

var $ = $B.args('__mul__', 2, {self: null, value: null}, arguments)

var self = $.self,

value = $.value

var v = $B.PyNumber_Index(value)

var source = self.source.slice()

for(var i = 0; i < v; i++){

for(var item of self.source){

source[source.length] = item

}

}

var cls = $B.is_bytes(self) ? _b_.bytes : _b_.bytearray

return {

ob_type: cls,

source

}

}

function nb_remainder(){

// PEP 461

var $ = $B.args('__mod__', 2, {self: null, args: null}, arguments)

var self = $.self,

args = $.args

var s = decode(self, "latin-1", "strict"),

res = $B.printf_format(s, 'bytes', args)

return _b_.str.tp_funcs.encode(res, "ascii")

}

function partition(){

var $ = $B.args('partition', 2, {self:null, sep:null}, arguments)

var self = $.self,

sep = $.sep

check_buffer(sep)

var len = sep.source.length,

src = self.source,

i = bytes_funcs.find(self, sep)

return _b_.tuple.$factory([

this.$factory(src.slice(0, i)),

this.$factory(src.slice(i, i + len)),

this.$factory(src.slice(i + len))

])

}

function removeprefix(self, prefix){

var $ = $B.args('removeprefix', 2, {self:null, prefix: null}, arguments)

var self = $.self,

prefix = $.prefix

check_buffer(prefix)

var seq = get_list_from_bytes_like(prefix)

var found = true

for(var i = 0, seq_len = seq.length; i < seq_len; i++){

if(self.source[i] != seq[i]){

found = false

break

}

}

if(found){

return {

ob_type: $B.get_class(self),

source: self.source.slice(seq_len)

}

}

return self

}

function removesuffix(self, prefix){

var $ = $B.args('removesuffix', 2, {self:null, prefix: null}, arguments)

var self = $.self,

prefix = $.prefix

check_buffer(prefix)

var seq = get_list_from_bytes_like(prefix)

var found = true

var len = self.source.length,

seq_len = seq.length

for(var i = 0; i < seq_len; i++){

if(self.source[len - seq_len + i] != seq[i]){

found = false

break

}

}

if(found){

return {

ob_type: $B.get_class(self),

source: self.source.slice(0, len - seq_len)

}

}

return self

}

function replace(){

var $ = $B.args('replace', 4,

{self: null, old: null, new: null, count: null},

arguments, {count: -1})

var res = []

var self = $.self,

src = self.source,

len = src.length,

old = $.old,

$new = $.new

var count = $.count >= 0 ? $.count : src.length

check_buffer($.old)

check_buffer($.new)

for(var i = 0; i < len; i++){

if(bytes_funcs.startswith(self, old, i) && count){

for(var j = 0; j < $new.source.length; j++){

res.push($new.source[j])

}

i += (old.source.length - 1)

count--

}else{

res.push(src[i])

}

}

return this.$factory(res)

}

function rjust() {

var $ = $B.args('rjust', 3, {self: null, width: null, fillbyte: null},

arguments, {fillbyte: bytes.$factory([32])})

var self = $.self,

width = $.width,

fillbyte = $.fillbyte

check_buffer(fillbyte)

var padding = [],

count = width - self.source.length

for(var i = 0; i < count; ++i){

padding.push(fillbyte.source[0])

}

return this.$factory(padding.concat(self.source))

}

function rpartition(){

var $ = $B.args('rpartition', 2, {self:null, sep:null}, arguments)

var self = $.self,

sep = $.sep

check_buffer(sep)

var len = sep.source.length,

src = self.source,

i = bytes_funcs.rfind(self, sep)

return _b_.tuple.$factory([

this.$factory(src.slice(0, i)),

this.$factory(src.slice(i, i + len)),

this.$factory(src.slice(i + len))

])

}

function rsplit(){

var $ = $B.args('rsplit', 3, {self:null, sep:null, maxsplit: null},

arguments, {sep: _b_.None, maxsplit: -1})

var self = $.self,

sep = $.sep,

maxsplit = $.maxsplit

var cls = this

var reversed_self = $B.fast_bytes(self.source.toReversed())

if(! $B.is_int(maxsplit)){

$B.RAISE(_b_.ValueError,

`maxsplit should be int, not ${$B.class_name(maxsplit)}`

)

}

var parts = [] // array of arrays of bytes

if(sep === _b_.None){

parts = bytes_split_with_whitespace(cls, self, maxsplit)

}else{

if($B.$getattr(sep, '__buffer__', $B.NULL) === $B.NULL){

$B.RAISE(_b_.TypeError,

`a bytes-like object is required, not '${$B.class_name(sep)}'`

)

}

var reversed_seps = Array.from($B.make_js_iterator(sep)).reverse()

parts = bytes_split_with_sep(cls, reversed_self, reversed_seps, maxsplit)

}

// restore order

parts.reverse()

for(part of parts){

part.reverse()

}

parts = parts.map(t => this.$factory(t))

return $B.$list(parts)

}

function sq_contains(self, other){

var [self, other] = self_other_args('__contains__', arguments)

if(typeof other == "number"){

return self.source.indexOf(other) > -1

}

if(! is_bytes_like(other)){

return false

}

var seq = get_list_from_bytes_like(other)

if(self.source.length < seq.length){

return false

}

var len = self.source.length

var seq_len = seq.length

for(var i = 0; i < len - seq_len + 1; i++){

var flag = true

for(var j = 0; j < seq_len; j++){

if(self.source[i + j] != seq[j]){

flag = false

break

}

}

if(flag){

return true

}

}

return false

}

function split(){

var $ = $B.args('split', 3, {self:null, sep:null, maxsplit: null},

arguments, {sep: _b_.None, maxsplit: -1})

var self = $.self,

sep = $.sep,

maxsplit = $.maxsplit

var cls = this // bytes or bytearray

if(! $B.is_int(maxsplit)){

$B.RAISE(_b_.ValueError,

`maxsplit should be int, not ${$B.class_name(maxsplit)}`

)

}

var parts = [] // array of arrays of bytes

if(sep === _b_.None){

parts = bytes_split_with_whitespace(cls, self, maxsplit)

}else{

if($B.$getattr(sep, '__buffer__', $B.NULL) === $B.NULL){

$B.RAISE(_b_.TypeError,

`a bytes-like object is required, not '${$B.class_name(sep)}'`

)

}

var seps = Array.from($B.make_js_iterator(sep))

parts = bytes_split_with_sep(cls, self, seps, maxsplit)

}

return $B.$list(parts)

}

function splitlines(){

var $ = $B.args('splitlines', 2, {self: null, keepends: null},

arguments, {keepends: false})

var self = $.self,

keepends = $.keepends

var cls = this // bytes or bytearray

if(!$B.$isinstance(keepends,[_b_.bool, _b_.int])){

throw _b_.TypeError('integer argument expected, got '+

$B.get_class(keepends).__name)

}

var keepends = $B.int_value(keepends),

res = $B.$list([]),

source = self.source,

start = 0,

pos = 0

if(! source.length){

return res

}

while(pos < source.length){

if (pos < source.length - 1 && source[pos] == 0x0d &&

source[pos + 1] == 0x0a){

res.push(cls.$factory(source.slice(start, keepends ? pos + 2 : pos)))

start = pos = pos + 2

}else if(source[pos] == 0x0d || source[pos] == 0x0a){

res.push(cls.$factory(source.slice(start, keepends ? pos + 1 : pos)))

start = pos = pos + 1

}else{

pos++

}

}

if(start < source.length){

res.push(cls.$factory(source.slice(start)))

}

return $B.$list(res)

}

function startswith(){

var $ = $B.args('startswith', 3, {self: null, prefix: null, start:null},

arguments, {start:0})

var self = $.self,

prefix = $.prefix,

start = $.start

var cls = this // bytes or bytearray

if($B.$isinstance($.prefix, [bytes, bytearray])){

let res = true

for(let i = 0; i < prefix.source.length && res; i++){

res = self.source[start + i] == prefix.source[i]

}

return res

}else if($B.is_tuple(prefix)){

let items = []

for(let i = 0; i < prefix.length; i++){

if($B.$isinstance(prefix[i], [bytes, bytearray])){

items = items.concat(prefix[i].source)

}else{

$B.RAISE(_b_.TypeError, "startswith first arg must be " +

"bytes or a tuple of bytes, not " +

$B.class_name(prefix))

}

}

let prefix = cls.$factory(items)

return startswith.call(cls, self, prefix, start)

}else{

$B.RAISE(_b_.TypeError, "startswith first arg must be bytes " +

"or a tuple of bytes, not " + $B.class_name(prefix))

}

}

function upper(){

var self = self_arg('upper', arguments)

var _res = [],

pos = 0

for(var i = 0, len = self.source.length; i < len; i++){

if(self.source[i]){_res[pos++] = _upper(self.source[i])}

}

return main_type(self).$factory(_res)

}

function swapcase(){

var self = $B.single_arg('swapcase', 'self', arguments)

var src = self.source,

len = src.length,

buffer = src.slice()

var cls = this

for(var i = 0; i < len; ++i){

if(buffer[i] > 96 && buffer[i] < 123){

buffer[i] -= 32

}else if (buffer[i] > 64 && buffer[i] < 91){

buffer[i] += 32

}

}

return cls.$factory(buffer)

}

function title(){

var self = $B.single_arg('title', 'self', arguments)

var cls = this // bytes or bytearray

var src = self.source,

len = src.length,

buffer = src.slice(),

current_char_is_letter = false,

prev_char_was_letter = false,

is_uppercase = false,

is_lowercase = false

for(var i = 0; i < len; ++i){

is_lowercase = buffer[i] > 96 && buffer[i] < 123

is_uppercase = buffer[i] > 64 && buffer[i] < 91

current_char_is_letter = is_lowercase || is_uppercase

if(current_char_is_letter){

if(prev_char_was_letter && is_uppercase){

buffer[i] += 32

}else if(! prev_char_was_letter && is_lowercase){

buffer[i] -= 32

}

}

prev_char_was_letter = current_char_is_letter

}

return cls.$factory(buffer)

}

function translate(){

var $ = $B.args('translate', 3, {self: null, table: null, _delete: null},

arguments, {_delete: $B.NULL})

var self = $.self,

table = $.table,

_delete = $._delete