nadesiko3 3.2.27

package/src/plugin_kansuji.js

@@ -0,0 +1,224 @@
+// @ts-nocheck
+const PluginKansuji = {
+
+  '初期化': {
+    type: 'func',
+    josi: [],
+    pure: true,
+    fn: function (sys) {
+    }
+  },
+
+  // @漢数字関連
+  '漢数字': { // @引数を数字と解釈して漢数字の文字列を返す // @かんすうじ
+    type: 'func',
+    josi: [['を', 'の']],
+    pure: true,
+    fn: function (input) {
+      function preprocesser (input) {
+        // eslint-disable-next-line camelcase
+        function if_number_is_exponent (input) {
+          const match = input.match(/[0-9]*\.?[0-9]+[eE][-+]?[0-9]+/)
+          if (match && match[0] === input) {
+            const base = input.match(/[0-9]*\.?[0-9]+[eE]/)[0].slice(0, -1)
+            const exponent = input.match(/[eE][-+]?[0-9]+/)[0].slice(1)
+            // eslint-disable-next-line no-inner-declarations
+            function movepoint (base, exponent) {
+              const sign = exponent[0]
+              const curpointidx = base.includes('.') ? base.indexOf('.') : base.length
+              const idx = sign === '-' ? curpointidx - parseInt(exponent.slice(1)) : curpointidx + parseInt(exponent.match(/[0-9]+$/)[0])
+              function strIns (str, idx, val) {
+                return str.slice(0, idx) + val + str.slice(idx)
+              }
+              if (idx > 0) {
+                if (base.length - curpointidx > idx) {
+                  return strIns(base.replace('.', ''), idx, '.')
+                } else {
+                  if (base.includes('.')) {
+                    return base.replace('.', '') + '0'.repeat(idx - base.length + curpointidx)
+                  } else {
+                    return base + '0'.repeat(idx - base.length + curpointidx - 1)
+                  }
+                }
+              } else {
+                return '0.' + '0'.repeat(-idx) + base.replace('.', '')
+              }
+            }
+            input = movepoint(base, exponent)
+          }
+          return input
+        }
+        function asciify (input) { // 全角数字を半角数字に
+          return input.replace(/[０-９]/g, s => {
+            return String.fromCharCode(s.charCodeAt(0) - 65248)
+          })
+        }
+        input = asciify(input)
+        if (Number.isNaN(Number(input))) { throw new Error('『漢数字』命令の中に無効な文字が含まれています。') }
+        const output = if_number_is_exponent(input.toString())
+        // eslint-disable-next-line no-loss-of-precision
+        if (output > BigInt(999999999999999999999999999999999999999999999999999999999999999999999999)) { throw new Error('『漢数字』命令の中に含められる数の大きさを超えています。') }
+        return output
+      }
+      input = preprocesser(String(input))
+      function separater (str) {
+        let isminus = str.includes('.')
+        return str.split('').reverse().reduce((acc, cur) => {
+          if (cur === '.') {
+            isminus = false
+            acc.splice(1, 0, '.')
+            return acc
+          } else if (isminus) {
+            acc.splice(1, 0, cur)
+            return acc
+          }
+          if (acc[0].length === 軸数字.length) {
+            acc.unshift([])
+          }
+          acc[0].unshift(cur)
+          return acc
+        }, [[]])
+      }
+      function converter (arr) {
+        function replacer (str) {
+          return 基本漢数字[基本算用数字.indexOf(str)]
+        }
+        let adjuster = 0
+        const result = arr.reverse().reduce((acc, cur, idx) => {
+          if (typeof cur === 'string') {
+            if (cur === '.') {
+              acc = '・' + acc
+              adjuster = idx + 1
+            } else {
+              acc = replacer(cur) + acc
+            }
+          } else {
+            const unit = cur.reduce((acc, cur, idx, src) => {
+              if (cur === '0') {
+                return acc
+              } else if (cur === '1' && 軸数字[src.length - 1 - idx] !== '') {
+                return acc + 軸数字[src.length - 1 - idx]
+              } else {
+                return acc + replacer(cur) + 軸数字[src.length - 1 - idx]
+              }
+            }, '')
+            acc = (unit ? unit + 単位数字[idx - adjuster] : '') + acc
+          }
+          return acc
+        }, '')
+        return result[0] === '・' ? '零' + result : result
+      }
+      // フラグを覚えておく #874
+      let flag = ''
+      if (input.charAt(0) === '+' || input.charAt(0) === '-') {
+        flag = input.charAt(0)
+        input = input.substr(1)
+      }
+      let res = converter(separater(input))
+      if (res === '') { res = '零' }
+      return flag + res
+    }
+  },
+  '算用数字': { // @U引数を漢数字と解釈して数値を返す // @さんようすうじ
+    type: 'func',
+    josi: [['を', 'の']],
+    pure: true,
+    fn: function (input) {
+      function converter (src) {
+        const multibytes = 単位数字.filter(a => a.length > 1)
+        const result = []
+        for (let idx = 0; idx < src.length; idx++) {
+          const cur = src.slice(idx, idx + 1)
+          const 指数 = 単位数字.includes(cur) ? cur : multibytes.find(v => v === src.slice(idx, idx + v.length))
+          const 位 = 軸数字.includes(cur) ? cur : null
+          const 底 = 基本漢数字.includes(cur) ? cur : null
+          if (指数) {
+            if (指数.length > 1) {
+              idx += 指数.length - 1
+            }
+            result.push(BigInt('1' + '0'.repeat(4 * 単位数字.indexOf(指数))))
+          } else if (位) {
+            result.push(10 ** (軸数字.indexOf(位)))
+          } else if (底) {
+            result.push(基本漢数字.indexOf(底))
+          } else if (cur === '・') {
+            result.push('.')
+          } else if (cur === '零') {
+            result.push('0')
+          } else {
+            throw new Error('『算用数字』命令の中に無効な文字が含まれています。')
+          }
+        }
+        return result
+      }
+      function separater (arr) {
+        let base = []
+        let unit = []
+        let isminus = false
+        return arr.reduce((acc, cur, idx) => {
+          if (cur === '.') {
+            if (base.length === 0) { base.push(0, 1) }
+            if (base.length === 1) { base.push(1) }
+            unit.push(base)
+            base = []
+            acc.push(unit)
+            acc.push('.')
+            unit = []
+            isminus = true
+          } else if (isminus) {
+            acc.push(String(cur))
+          } else if (cur > 1000) {
+            if (base.length === 0) { base.push(0, 1) }
+            if (base.length === 1) { base.push(1) }
+            unit.push(base)
+            base = []
+            unit.push(cur)
+            acc.push(unit)
+            unit = []
+          } else if (cur >= 10 && cur <= 1000) {
+            if (base.length === 0) { base.push(1) }
+            base.push(cur)
+            unit.push(base)
+            base = []
+          } else if (cur < 10) {
+            base.push(cur)
+          }
+          if (idx + 1 === arr.length && isminus === false) {
+            if (base.length === 1) {
+              base.push(1)
+              unit.push(base)
+            }
+            acc.push(unit)
+          }
+          return acc
+        }, [])
+      }
+      function calculator (arr) {
+        return arr.reduce((acc, cur, idx) => {
+          return typeof cur === 'string'
+            ? acc + cur
+            : acc + cur.reduce((acc, cur, idx) => {
+              return cur > 1000 ? acc * cur : acc + BigInt(cur[0] * cur[1])
+            }, BigInt(0))
+        }, BigInt(0))
+      }
+      const tmp = calculator(separater(converter(input.toString())))
+      return tmp > Number.MAX_SAFE_INTEGER ? tmp : Number(tmp)
+    }
+  }
+}
+
+const 単位数字 = [
+  '', '万', '億', '兆', '京', '垓', '𥝱', '穣', '溝', '澗', '正',
+  '載', '極', '恒河沙', '阿僧祇', '那由他', '不可思議', '無量大数'
+]
+const 軸数字 = [
+  '', '十', '百', '千'
+]
+const 基本算用数字 = '0123456789'.split('')
+const 基本漢数字 = '〇一二三四五六七八九'.split('')
+
+module.exports = PluginKansuji
+
+// scriptタグで取り込んだ時、自動で登録する
+if (typeof (navigator) === 'object' && typeof (navigator.nako3) === 'object') { navigator.nako3.addPluginObject('PluginKansuji', PluginKansuji) }

package/src/plugin_keigo.js

@@ -0,0 +1,55 @@
+// @ts-nocheck
+// 敬語を使いたい人のためのプラグイン (お遊び機能)
+
+const PluginKeigo = {
+  '初期化': {
+    type: 'func',
+    josi: [],
+    pure: true,
+    fn: function (sys) {
+    }
+  },
+  // @丁寧語
+  'お世話': { type: 'const', value: 1 }, // @おせわ
+  'な': { // @Aになる // @なる
+    type: 'func',
+    josi: [['に', 'へ']],
+    pure: true,
+    fn: function (a, sys) {
+      return a
+    }
+  },
+  'おります': { // @ソースコードを読む人を気持ちよくする // @おります
+    type: 'func',
+    josi: [],
+    pure: true,
+    fn: function (sys) {
+      if (!sys.__reisetu) { sys.__reisetu = 0 }
+      sys.__reisetu++
+    },
+    return_none: true
+  },
+  'どうぞ': { // @ソースコードを読む人を気持ちよくする // @どうぞ
+    type: 'func',
+    josi: [],
+    pure: true,
+    fn: function (sys) {
+      if (!sys.__reisetu) { sys.__reisetu = 0 }
+      sys.__reisetu++
+    },
+    return_none: true
+  },
+  'よろしくお願': { // @ソースコードを読む人を気持ちよくする // @よろしくおねがいします
+    type: 'func',
+    josi: [],
+    pure: true,
+    fn: function (sys) {
+      if (!sys.__reisetu) { sys.__reisetu = 0 }
+      sys.__reisetu++
+    },
+    return_none: true
+  }
+
+}
+
+module.exports = PluginKeigo

package/src/plugin_markup.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+/**
+ * file: plugin_markup.js
+ * マークアップ言語関連のプラグイン
+ */
+const PluginMarkup = {
+  // @マークアップ
+  'マークダウンHTML変換': { // @マークダウン形式で記述された文字列SをHTML形式に変換する // @まーくだうんHTMLへんかん
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function (s) {
+      const marked = require('marked')
+      const html = marked(s)
+      return html
+    }
+  },
+  'HTML整形': { // @HTML形式で記述された文字列Sを整形する // @HTMLせいけい
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function (s) {
+      const html = require('html')
+      return html.prettyPrint(s, { indent_size: 2 })
+    }
+  }
+}
+
+module.exports = PluginMarkup
+
+// scriptタグで取り込んだ時、自動で登録する
+if (typeof (navigator) === 'object') { navigator.nako3.addPluginObject('PluginMarkup', PluginMarkup) }

package/src/plugin_math.js

@@ -0,0 +1,319 @@
+// @ts-nocheck
+const PluginMath = {
+  '初期化': {
+    type: 'func',
+    josi: [],
+    pure: true,
+    fn: function (sys) {
+    }
+  },
+  // @三角関数
+  'SIN': { // @ラジアン単位VのSINを求める // @SIN
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (v) {
+      return Math.sin(v)
+    }
+  },
+  'COS': { // @ラジアン単位VのCOSを求める // @COS
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (v) {
+      return Math.cos(v)
+    }
+  },
+  'TAN': { // @ラジアン単位VのTANを求める // @TAN
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (v) {
+      return Math.tan(v)
+    }
+  },
+  'ARCSIN': { // @ラジアン単位VのARCSINを求める // @ARCSIN
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (v) {
+      return Math.asin(v)
+    }
+  },
+  'ARCCOS': { // @ラジアン単位VのARCCOSを求める // @ARCCOS
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (v) {
+      return Math.acos(v)
+    }
+  },
+  'ARCTAN': { // @ラジアン単位VのARCTANを求める // @ARCTAN
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (v) {
+      return Math.atan(v)
+    }
+  },
+  'ATAN2': { // @ARCTAN(Y/X)をラジアン単位で返す // @ATAN2
+    type: 'func',
+    josi: [['と'], ['の']],
+    pure: true,
+    fn: function (y, x) {
+      return Math.atan2(y, x)
+    }
+  },
+  '座標角度計算': { // @点[0,0]から[x,y]の直線とX軸の角度(度)を返す // @ざひょうかくどけいさん
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (XY) {
+      return Math.atan2(XY[1], XY[0]) * 180 / Math.PI
+    }
+  },
+  'RAD2DEG': { // @ラジアンから度に変換 // @RAD2DEG
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function (v) {
+      return v / Math.PI * 180
+    }
+  },
+  'DEG2RAD': { // @度からラジアンに変換 // @DEG2RAD
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function (v) {
+      return (v / 180) * Math.PI
+    }
+  },
+  '度変換': { // @ラジアンから度に変換 // @どへんかん
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function (v) {
+      return v / Math.PI * 180
+    }
+  },
+  'ラジアン変換': { // @度からラジアンに変換 // @らじあんへんかん
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function (v) {
+      return (v / 180) * Math.PI
+    }
+  },
+
+  // @算術関数
+  'SIGN': { // @Vが0なら0を、0超なら1を、0未満なら-1を返す // @SIGN
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (v) {
+      return (parseFloat(v) === 0) ? 0 : (v > 0) ? 1 : -1
+    }
+  },
+  '符号': { // @Vが0なら0を、0超なら1を、0未満なら-1を返す // @ふごう
+    type: 'func',
+    josi: [['の']],
+    pure: false,
+    fn: function (v, sys) {
+      return sys.__exec('SIGN', [v])
+    }
+  },
+  'ABS': { // @Vの絶対値を返す // @ABS
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (a) {
+      return Math.abs(a)
+    }
+  },
+  '絶対値': { // @Vの絶対値を返す // @ぜったいち
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (a) {
+      return Math.abs(a)
+    }
+  },
+  'EXP': { // @e（自然対数の底）の A 乗の値を返す // @EXP
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (a) {
+      return Math.exp(a)
+    }
+  },
+  'HYPOT': { // @直角三角形の二辺の長さA,Bから斜辺を求めて返す。 // @HYPOT
+    type: 'func',
+    josi: [['と'], ['の']],
+    pure: true,
+    fn: function (a, b) {
+      return Math.hypot(a, b)
+    }
+  },
+  '斜辺': { // @直角三角形の二辺の長さA,Bから斜辺を求めて返す。 // @しゃへん
+    type: 'func',
+    josi: [['と'], ['の']],
+    pure: true,
+    fn: function (a, b) {
+      return Math.hypot(a, b)
+    }
+  },
+  'LN': { // @実数式 A の自然対数（Ln(A) = 1）を返す // @LN
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (a) {
+      return Math.log(a)
+    }
+  },
+  'LOG': { // @Aの自然対数（底はE）を返す // @LOG
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (a) {
+      return Math.log(a)
+    }
+  },
+  'LOGN': { // @指定された底AでBの対数を計算して返す // @LOGN
+    type: 'func',
+    josi: [['で'], ['の']],
+    pure: true,
+    fn: function (a, b) {
+      if (a === 2) { return Math.LOG2E * Math.log(b) }
+      if (a === 10) { return Math.LOG10E * Math.log(b) }
+      return Math.log(b) / Math.log(a)
+    }
+  },
+  'FRAC': { // @実数Aの小数部分を返す // @FRAC
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (a) {
+      return a % 1
+    }
+  },
+  '小数部分': { // @実数Aの小数部分を返す // @しょうすうぶぶん
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (a) {
+      return a % 1
+    }
+  },
+  '整数部分': { // @実数Aの整数部分を返す // @せいすうぶぶん
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (a) {
+      return Math.trunc(a)
+    }
+  },
+  '乱数': { // @0から(A-1)までの乱数を返す // @らんすう
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (a) {
+      return Math.floor(Math.random() * a)
+    }
+  },
+  'SQRT': { // @Aの平方根を返す // @SQRT
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (a) {
+      return Math.sqrt(a)
+    }
+  },
+  '平方根': { // @Aの平方根を返す // @へいほうこん
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function (a) {
+      return Math.sqrt(a)
+    }
+  },
+
+  // @数値切上切捨丸め
+  'ROUND': { // @実数型の値Vを丸めてもっとも近い整数値を返す // @ROUND
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function (v) {
+      return Math.round(v)
+    }
+  },
+  '四捨五入': { // @実数型の値Vを丸めてもっとも近い整数値を返す // @ししゃごにゅう
+    type: 'func',
+    josi: [['を', 'の']],
+    pure: true,
+    fn: function (v) {
+      return Math.round(v)
+    }
+  },
+  '小数点切上': { // @整数Aを小数点第B桁で切り上げして返す // @しょうすうてんきりあげ
+    type: 'func',
+    josi: [['を'], ['で']],
+    pure: true,
+    fn: function (a, b) {
+      const base = Math.pow(10, b)
+      return Math.ceil(a * base) / base
+    }
+  },
+  '小数点切下': { // @整数Aを小数点第B桁で切り下げして返す // @しょうすうてんきりさげ
+    type: 'func',
+    josi: [['を'], ['で']],
+    pure: true,
+    fn: function (a, b) {
+      const base = Math.pow(10, b)
+      return Math.floor(a * base) / base
+    }
+  },
+  '小数点四捨五入': { // @実数Aを小数点第B桁で四捨五入して返す // @しょうすうてんししゃごにゅう
+    type: 'func',
+    josi: [['を'], ['で']],
+    pure: true,
+    fn: function (a, b) {
+      const base = Math.pow(10, b)
+      return Math.round(a * base) / base
+    }
+  },
+  'CEIL': { // @数値を正の無限大方向へ切り上げて返す。 // @CEIL
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function (v) {
+      return Math.ceil(v)
+    }
+  },
+  '切上': { // @数値を正の無限大方向へ切り上げて返す。 // @きりあげ
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function (v) {
+      return Math.ceil(v)
+    }
+  },
+  'FLOOR': { // @数値を負の無限大方向へ切り下げて返す。 // @FLOOR
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function (v) {
+      return Math.floor(v)
+    }
+  },
+  '切捨': { // @数値を負の無限大方向へ切り下げて返す。// @きりすて
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function (v) {
+      return Math.floor(v)
+    }
+  }
+
+}
+
+module.exports = PluginMath