nadesiko3 3.7.21 → 3.7.22

package/core/src/plugin_system_array.mts

@@ -0,0 +1,699 @@
+/**
+ * @fileOverview なでしこ3 plugin_system の分割ファイル
+ *
+ * 配列操作・二次元配列処理の命令を定義する。
+ * このファイルは単独のプラグインではなく、plugin_system.mts へマージされる。(#2351)
+ */
+export default {
+  // @配列操作
+  '配列結合': { // @配列Aを文字列Sでつなげて文字列で返す // @はいれつけつごう
+    type: 'func',
+    josi: [['を'], ['で']],
+    pure: true,
+    fn: function(a: any, s: string): string {
+      // 配列ならOK
+      if (a instanceof Array) { return a.join('' + s) }
+
+      const a2 = String(a).split('\n') // 配列でなければ無理矢理改行で区切ってみる
+      return a2.join('' + s)
+    }
+  },
+  '配列只結合': { // @配列Aの要素をただ結合して文字列で返す。(「」で配列結合と同じ) // @はいれつただけつごう
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function(a: any): string {
+      if (a instanceof Array) { return a.join('') }
+      const a2 = String(a).split('\n') // 配列でなければ無理矢理改行で区切ってみる
+      return a2.join('')
+    }
+  },
+  '配列検索': { // @配列Aから文字列Sを探してインデックス番号(0起点)を返す。見つからなければ-1を返す。 // @はいれつけんさく
+    type: 'func',
+    josi: [['の', 'から'], ['を']],
+    pure: true,
+    fn: function(a: any, s: any) {
+      if (a instanceof Array) { return a.indexOf(s) }// 配列ならOK
+
+      return -1
+    }
+  },
+  '配列要素数': { // @配列Aの要素数を返す // @はいれつようそすう
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(a: any) {
+      if (a instanceof Array) { return a.length }// 配列ならOK
+      if (a instanceof Object) { return Object.keys(a).length } // オブジェクト
+      if (typeof a === 'string') { return String(a).length } // 文字列
+      return 1
+    }
+  },
+  '要素数': { // @Aの要素数を返す。Aには配列/辞書型/文字列を指定する。 // @ようそすう
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(a: any, sys: any) {
+      return sys.__exec('配列要素数', [a])
+    }
+  },
+  'LEN': { // @Aの要素数を返す。Aには配列/辞書型/文字列を指定する。 // @LEN
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(a: any, sys: any) {
+      return sys.__exec('配列要素数', [a])
+    }
+  },
+  '配列挿入': { // @配列AのI番目(0起点)に要素Sを追加して返す(v1非互換) // @はいれつそうにゅう
+    type: 'func',
+    josi: [['の'], ['に', 'へ'], ['を']],
+    pure: true,
+    fn: function(a: any, i: any, s: any) {
+      if (a instanceof Array) { return a.splice(i, 0, s) } // 配列ならOK
+
+      throw new Error('『配列挿入』で配列以外の要素への挿入。')
+    }
+  },
+  '配列一括挿入': { // @配列AのI番目(0起点)に配列bを追加して返す(v1非互換) // @はいれついっかつそうにゅう
+    type: 'func',
+    josi: [['の'], ['に', 'へ'], ['を']],
+    pure: true,
+    fn: function(a: any, i: number, b: any) {
+      if (a instanceof Array && b instanceof Array) { // 配列ならOK
+        for (let j = 0; j < b.length; j++) { a.splice(i + j, 0, b[j]) }
+
+        return a
+      }
+      throw new Error('『配列一括挿入』で配列以外の要素への挿入。')
+    }
+  },
+  '配列ソート': { // @配列Aをソートして返す(A自体を変更) // @はいれつそーと
+    type: 'func',
+    josi: [['の', 'を']],
+    pure: true,
+    fn: function(a: any) {
+      if (a instanceof Array) { return a.sort() } // 配列ならOK
+
+      throw new Error('『配列ソート』で配列以外が指定されました。')
+    }
+  },
+  '配列数値変換': { // @配列Aの各要素を数値に変換して返す(変数A自体を変更) // @はいれつすうちへんかん
+    type: 'func',
+    josi: [['の', 'を']],
+    pure: true,
+    fn: function(a: any) {
+      // 配列ならOK
+      if (a instanceof Array) {
+        for (let i = 0; i < a.length; i++) {
+          a[i] = parseFloat(a[i])
+        }
+        return a
+      }
+      throw new Error('『配列数値変換』で配列以外が指定されました。')
+    }
+  },
+  '配列数値ソート': { // @配列Aをソートして返す(A自体を変更) // @はいれつすうちそーと
+    type: 'func',
+    josi: [['の', 'を']],
+    pure: true,
+    fn: function(a: any) {
+      // 配列ならOK
+      if (a instanceof Array) {
+        return a.sort((a, b) => {
+          return parseFloat(a) - parseFloat(b)
+        })
+      }
+
+      throw new Error('『配列数値ソート』で配列以外が指定されました。')
+    }
+  },
+  '配列カスタムソート': { // @関数Fで配列Aをソートして返す(引数A自体を変更) // @はいれつかすたむそーと
+    type: 'func',
+    josi: [['で'], ['の', 'を']],
+    pure: false,
+    fn: function(f: any, a: any, sys: any) {
+      let ufunc = f
+      if (typeof f === 'string') {
+        ufunc = sys.__findFunc(f, '配列カスタムソート')
+      }
+      if (a instanceof Array) {
+        return a.sort(ufunc)
+      }
+      throw new Error('『配列カスタムソート』で配列以外が指定されました。')
+    }
+  },
+  '配列逆順': { // @配列Aを逆にして返す。Aを書き換える(A自体を変更)。 // @はいれつぎゃくじゅん
+    type: 'func',
+    josi: [['の', 'を']],
+    pure: true,
+    fn: function(a: any) {
+      if (a instanceof Array) { return a.reverse() } // 配列ならOK
+      throw new Error('『配列ソート』で配列以外が指定されました。')
+    }
+  },
+  '配列シャッフル': { // @配列Aをシャッフルして返す。Aを書き換える // @はいれつしゃっふる
+    type: 'func',
+    josi: [['の', 'を']],
+    pure: true,
+    fn: function(a: any) {
+      if (a instanceof Array) { // 配列ならOK
+        for (let i = a.length - 1; i > 0; i--) {
+          const r = Math.floor(Math.random() * (i + 1))
+          const tmp = a[i]
+          a[i] = a[r]
+          a[r] = tmp
+        }
+        return a
+      }
+      throw new Error('『配列シャッフル』で配列以外が指定されました。')
+    }
+  },
+  '配列削除': { // @配列AのI番目(0起点)の要素を削除して返す。Aの内容を書き換える。辞書型変数ならキーIを削除する。 // @はいれつさくじょ
+    type: 'func',
+    josi: [['の', 'から'], ['を']],
+    pure: true,
+    fn: function(a: any, i: any, sys: any) {
+      return sys.__exec('配列切取', [a, i, sys])
+    }
+  },
+  '配列切取': { // @配列AのI番目(0起点)の要素を切り取って返す。Aの内容を書き換える。引数Iには範囲オブジェクトを指定できる。その場合戻り値は配列型となる。辞書型変数ならキーIを削除する。 // @はいれつきりとる
+    type: 'func',
+    josi: [['の', 'から'], ['を']],
+    pure: true,
+    fn: function(a: any, i: any) {
+      // 配列変数のとき
+      if (a instanceof Array) {
+        if (typeof i === 'number') {
+          const b = a.splice(i, 1)
+          if (b instanceof Array) { return b[0] } // 切り取った戻り値は必ずArrayになるので。
+        }
+        if (typeof i === 'object' && typeof i['先頭'] === 'number') {
+          const idx = i['先頭']
+          const cnt = i['末尾'] - i['先頭'] + 1
+          return a.splice(idx, cnt)
+        }
+        return null
+      }
+      // 辞書型変数のとき
+      if (a instanceof Object && typeof (i) === 'string') { // 辞書型変数も許容
+        if (a[i]) {
+          const old = a[i]
+          delete a[i]
+          return old
+        }
+        return undefined
+      }
+      throw new Error('『配列切取』で配列以外を指定。')
+    }
+  },
+  '配列取出': { // @配列AのI番目(0起点)からCNT個の要素を取り出して返す。Aの内容を書き換える // @はいれつとりだし
+    type: 'func',
+    josi: [['の'], ['から'], ['を']],
+    pure: true,
+    fn: function(a: any, i: any, cnt: any) {
+      if (a instanceof Array) { return a.splice(i, cnt) }
+      throw new Error('『配列取出』で配列以外を指定。')
+    }
+  },
+  '配列ポップ': { // @配列Aの末尾を取り出して返す。Aの内容を書き換える。 // @はいれつぽっぷ
+    type: 'func',
+    josi: [['の', 'から']],
+    pure: true,
+    fn: function(a: any) {
+      if (a instanceof Array) { return a.pop() }
+      throw new Error('『配列ポップ』で配列以外の処理。')
+    }
+  },
+  '配列プッシュ': { // @配列Aの末尾にNを追加。Aの内容を書き換える。(『配列追加』と同じ) // @はいれつぷっしゅ
+    type: 'func',
+    josi: [['に', 'へ'], ['を']],
+    pure: true,
+    fn: function(a: any, b: any, sys: any) {
+      return sys.__exec('配列追加', [a, b, sys])
+    }
+  },
+  '配列追加': { // @配列Aの末尾にBを追加して返す。Aの内容を書き換える。 // @はいれつついか
+    type: 'func',
+    josi: [['に', 'へ'], ['を']],
+    pure: true,
+    fn: function(a: any, b: any) {
+      if (a instanceof Array) { // 配列ならOK
+        a.push(b)
+        return a
+      }
+      throw new Error('『配列追加』で配列以外の処理。')
+    }
+  },
+  '配列複製': { // @配列Aを複製して返す。 // @はいれつふくせい
+    type: 'func',
+    josi: [['を']],
+    pure: true,
+    fn: function(a: any) {
+      return JSON.parse(JSON.stringify(a))
+    }
+  },
+  '配列範囲コピー': { // @配列Aの範囲I(数値化範囲オブジェクト)を複製して返す。 // @はいれつはんいこぴー
+    type: 'func',
+    josi: [['の', 'から'], ['を']],
+    pure: true,
+    fn: function(a: any, i: any) {
+      if (!Array.isArray(a)) {
+        throw new Error('『配列範囲コピー』で配列以外の値が指定されました。')
+      }
+      if (typeof i === 'number') {
+        if (typeof a[i] === 'object') {
+          return JSON.parse(JSON.stringify(a[i]))
+        }
+        return a[i]
+      }
+      // 範囲オブジェクトのとき
+      if (typeof i === 'object' && typeof i['先頭'] === 'number') {
+        const start = i['先頭']
+        const last = Number(i['末尾']) + 1
+        return JSON.parse(JSON.stringify(a.slice(start, last)))
+      }
+      return undefined
+    }
+  },
+  '参照': { // @値A(配列/文字列/辞書型)の範囲I(キーまたは範囲オブジェクト)を参照して(コピーせず)返す // @さんしょう
+    type: 'func',
+    josi: [['から', 'の'], ['を']],
+    pure: true,
+    fn: function(a: any, i: any, _sys: any) {
+      // 文字列のとき
+      if (typeof a === 'string') {
+        if (typeof i === 'number') {
+          return a.charAt(i)
+        }
+        // 範囲オブジェクトのとき
+        if (typeof i === 'object' && typeof i['先頭'] === 'number') {
+          const start = i['先頭']
+          const last = Number(i['末尾']) + 1
+          return a.substring(start, last)
+        }
+        throw new Error(`『参照』で文字列型の範囲指定(${JSON.stringify(i)})が不正です。`)
+      }
+      // 配列型のとき
+      if (Array.isArray(a)) {
+        if (typeof i === 'number') {
+          return a[i]
+        }
+        // 範囲オブジェクトのとき
+        if (typeof i === 'object' && typeof i['先頭'] === 'number') {
+          const start = i['先頭']
+          const last = Number(i['末尾']) + 1
+          return a.slice(start, last)
+        }
+      }
+      // 辞書型のとき
+      if (typeof a === 'object') {
+        return a[i]
+      }
+      throw new Error('『参照』で文字列/配列/辞書型以外の値が指定されました。')
+    }
+  },
+  '配列参照': { // @値A(配列/文字列/辞書型)の範囲I(キーまたは範囲オブジェクト)を参照して(コピーせず)返す(『参照』と同じ) // @はいれつはんいさんしょう
+    type: 'func',
+    josi: [['の', 'から'], ['を']],
+    pure: true,
+    fn: function(a: any, i: any, sys: any) {
+      return sys.__exec('参照', [a, i, sys])
+    }
+  },
+  '配列足': { // @配列Aに配列Bを足し合わせて返す。 // @はいれつたす
+    type: 'func',
+    josi: [['に', 'へ', 'と'], ['を']],
+    pure: true,
+    fn: function(a: any, b: any) {
+      if (a instanceof Array) {
+        return a.concat(b)
+      }
+      return JSON.parse(JSON.stringify(a))
+    }
+  },
+  '配列最大値': { // @配列Aの値の最大値を調べて返す。 // @はいれつさいだいち
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(a: any) {
+      return a.reduce((x: any, y: any) => Math.max(x, y))
+    }
+  },
+  '配列最小値': { // @配列Aの値の最小値を調べて返す。 // @はいれつさいしょうち
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(a: any) {
+      return a.reduce((x: any, y: any) => Math.min(x, y))
+    }
+  },
+  '配列合計': { // @配列Aの値を全て足して返す。配列の各要素を数値に変換して計算する。数値に変換できない文字列は0になる。 // @はいれつごうけい
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(a: any) {
+      if (a instanceof Array) {
+        let v = 0
+        a.forEach((n) => {
+          const nn = parseFloat(n)
+          if (isNaN(nn)) { return }
+          v += nn
+        })
+        return v
+      }
+      throw new Error('『配列合計』で配列変数以外の値が指定されました。')
+    }
+  },
+  '配列入替': { // @配列Aの(0から数えて)I番目とJ番目の要素を入れ替えて返す。Aの内容を書き換える。// @はいれついれかえ
+    type: 'func',
+    josi: [['の'], ['と'], ['を']],
+    pure: true,
+    fn: function(a: any, i: number, j: number) {
+      if (!(a instanceof Array)) {
+        throw new Error('『配列入替』の第1引数には配列を指定してください。')
+      }
+      const tmp = a[i]
+      a[i] = a[j]
+      a[j] = tmp
+      return a
+    }
+  },
+  '配列連番作成': { // @AからBまでの連番配列を生成して返す。 // @はいれつれんばんさくせい
+    type: 'func',
+    josi: [['から'], ['までの', 'まで', 'の']],
+    pure: true,
+    fn: function(a: number, b: number) {
+      const result: number[] = []
+      for (let i = a; i <= b; i++) {
+        result.push(i)
+      }
+      return result
+    }
+  },
+  '配列要素作成': { // @値AをB個持つ配列を生成して返す。引数Bに配列を指定すると二次元以上の配列を生成する。// @はいれつようそさくせい
+    type: 'func',
+    josi: [['を'], ['だけ', 'で']],
+    pure: true,
+    fn: function(a: any, b: number | number[]) {
+      // value が配列やオブジェクトでも深くコピーするヘルパー
+      const cloneValue = (v: any): any => {
+        if (Array.isArray(v)) {
+          return (v).map(item => cloneValue(item)) as any
+        }
+        if (v instanceof Date) {
+          return new Date(v.getTime())
+        }
+        if (typeof v === 'object' && v !== null) {
+          return JSON.parse(JSON.stringify(v))
+        }
+        return v
+      }
+      // 再帰的に配列を生成する関数
+      const full = function(value: any, shape: number | number[]): any {
+        // 1次元：shape が数値
+        if (!Array.isArray(shape)) {
+          return Array.from({ length: shape }, () => cloneValue(value))
+        }
+        // 1次元：shape が数値
+        if (Array.isArray(shape) && shape.length === 1) {
+          return Array.from({ length: shape[0] }, () => cloneValue(value))
+        }
+        // 多次元：shape が配列
+        const [first, ...rest] = shape
+        return Array.from(
+          { length: first },
+          () => full(cloneValue(value), rest)
+        )
+      }
+      return full(a, b)
+    }
+  },
+  '配列関数適用': { // @引数を1つ持つ関数Fを、配列Aの全要素に適用した、新しい配列を返す。 // @はいれつかんすうてきよう
+    type: 'func',
+    josi: [['を'], ['へ', 'に']],
+    pure: true,
+    fn: function(f: any, a: any, sys: any) {
+      let ufunc: any = f
+      if (typeof f === 'string') { ufunc = sys.__findFunc(f, '配列関数適用') }
+      const result: any = []
+      for (const e of a) {
+        result.push(ufunc(e))
+      }
+      return result
+    }
+  },
+  '配列マップ': { // @引数を1つ持つ関数Fを、配列Aの全要素に適用した、新しい配列を返す。(『配列関数適用』と同じ) // @はいれつまっぷ
+    type: 'func',
+    josi: [['を'], ['へ', 'に']],
+    pure: true,
+    fn: function(f: any, a: any, sys: any) {
+      return sys.__exec('配列関数適用', [f, a, sys])
+    }
+  },
+  '配列フィルタ': { // @引数を1つ持ち真偽を返す関数Fを利用して、配列Aの要素をフィルタして、新しい配列として返す。 // @はいれつふぃるた
+    type: 'func',
+    josi: [['で', 'の'], ['を', 'について']],
+    pure: true,
+    fn: function(f: any, a: any, sys: any) {
+      let ufunc: any = f
+      if (typeof f === 'string') { ufunc = sys.__findFunc(f, '配列フィルタ') }
+      const result: any = []
+      for (const e of a) {
+        if (ufunc(e)) { result.push(e) }
+      }
+      return result
+    }
+  },
+
+  // @二次元配列処理
+  '表ソート': { // @二次元配列AでB列目(0起点)(あるいはキー名)をキーに文字列順にソートする。Aの内容を書き換える。 // @ひょうそーと
+    type: 'func',
+    josi: [['の'], ['を']],
+    pure: true,
+    fn: function(a: any, no: any) {
+      if (!(a instanceof Array)) {
+        throw new Error('『表ソート』には配列を指定する必要があります。')
+      }
+      a.sort((n, m) => {
+        const ns = n[no]
+        const ms = m[no]
+
+        if (ns === ms) {
+          return 0
+        } else if (ns < ms) {
+          return -1
+        } else {
+          return 1
+        }
+      })
+      return a
+    }
+  },
+  '表数値ソート': { // @二次元配列AでB列目(0起点)(あるいはキー名)をキーに数値順にソートする。Aの内容を書き換える。 // @ひょうすうちそーと
+    type: 'func',
+    josi: [['の'], ['を']],
+    pure: true,
+    fn: function(a: any, no: number) {
+      if (!(a instanceof Array)) {
+        throw new Error('『表数値ソート』には配列を指定する必要があります。')
+      }
+      a.sort((n, m) => {
+        const ns = n[no]
+        const ms = m[no]
+        return ns - ms
+      })
+      return a
+    }
+  },
+  '表ピックアップ': { // @配列Aの列番号B(0起点)(あるいはキー名)で検索文字列Sを含む行を返す // @ひょうぴっくあっぷ
+    type: 'func',
+    josi: [['の'], ['から'], ['を', 'で']],
+    pure: true,
+    fn: function(a: any, no: number, s: any) {
+      if (!(a instanceof Array)) { throw new Error('『表ピックアップ』には配列を指定する必要があります。') }
+      return a.filter((row) => String(row[no]).indexOf(s) >= 0)
+    }
+  },
+  '表完全一致ピックアップ': { // @配列Aの列番号B(0起点)(あるいはキー名)で検索文字列Sと一致する行を返す // @ひょうかんぜんいっちぴっくあっぷ
+    type: 'func',
+    josi: [['の'], ['から'], ['を', 'で']],
+    pure: true,
+    fn: function(a: any, no: number, s: any) {
+      if (!(a instanceof Array)) { throw new Error('『表完全ピックアップ』には配列を指定する必要があります。') }
+      return a.filter((row) => row[no] === s)
+    }
+  },
+  '表検索': { // @二次元配列AでCOL列目(0起点)からキーSを含む行をROW行目から検索して何行目にあるか返す。見つからなければ-1を返す。 // @ひょうけんさく
+    type: 'func',
+    josi: [['の'], ['で', 'に'], ['から'], ['を']],
+    pure: true,
+    fn: function(a: any, col: number, row: number, s: any) {
+      if (!(a instanceof Array)) { throw new Error('『表検索』には配列を指定する必要があります。') }
+      for (let i = row; i < a.length; i++) {
+        if (a[i][col] === s) { return i }
+      }
+      return -1
+    }
+  },
+  '表列数': { // @二次元配列Aの列数を調べて返す。 // @ひょうれつすう
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(a: any) {
+      if (!(a instanceof Array)) { throw new Error('『表列数』には配列を指定する必要があります。') }
+      let cols = 1
+      for (let i = 0; i < a.length; i++) {
+        if (a[i].length > cols) { cols = a[i].length }
+      }
+      return cols
+    }
+  },
+  '表行数': { // @二次元配列Aの行数を調べて返す。 // @ひょうぎょうすう
+    type: 'func',
+    josi: [['の']],
+    pure: true,
+    fn: function(a: any) {
+      if (!(a instanceof Array)) { throw new Error('『表行数』には配列を指定する必要があります。') }
+      return a.length
+    }
+  },
+  '表行列交換': { // @二次元配列Aの行と列を交換して返す。 // @ひょうぎょうれつこうかん
+    type: 'func',
+    josi: [['の', 'を']],
+    pure: true,
+    fn: function(a: any, sys: any) {
+      if (!(a instanceof Array)) { throw new Error('『表行列交換』には配列を指定する必要があります。') }
+      const cols = sys.__exec('表列数', [a])
+      const rows = a.length
+      const res = []
+      for (let r = 0; r < cols; r++) {
+        const row: any[] = []
+        res.push(row)
+        for (let c = 0; c < rows; c++) {
+          row[c] = (a[c][r] !== undefined) ? a[c][r] : ''
+        }
+      }
+      return res
+    }
+  },
+  '表右回転': { // @二次元配列Aを90度回転して返す。 // @ひょうみぎかいてん
+    type: 'func',
+    josi: [['の', 'を']],
+    pure: true,
+    fn: function(a: any, sys: any) {
+      if (!(a instanceof Array)) { throw new Error('『表右回転』には配列を指定する必要があります。') }
+      const cols = sys.__exec('表列数', [a])
+      const rows = a.length
+      const res = []
+      for (let r = 0; r < cols; r++) {
+        const row: any[] = []
+        res.push(row)
+        for (let c = 0; c < rows; c++) {
+          row[c] = a[rows - c - 1][r]
+        }
+      }
+      return res
+    }
+  },
+  '表重複削除': { // @二次元配列AのI列目にある重複項目を削除して返す。 // @ひょうじゅうふくさくじょ
+    type: 'func',
+    josi: [['の'], ['を', 'で']],
+    pure: true,
+    fn: function(a: any, i: any) {
+      if (!(a instanceof Array)) { throw new Error('『表重複削除』には配列を指定する必要があります。') }
+      const res: any[] = []
+      const keys:{[key: string]: boolean} = {}
+      for (let n = 0; n < a.length; n++) {
+        const k = a[n][i]
+        if (undefined === keys[k]) {
+          keys[k] = true
+          res.push(a[n])
+        }
+      }
+      return res
+    }
+  },
+  '表列取得': { // @二次元配列AのI列目を返す。 // @ひょうれつしゅとく
+    type: 'func',
+    josi: [['の'], ['を']],
+    pure: true,
+    fn: function(a: any, i: number) {
+      if (!(a instanceof Array)) { throw new Error('『表列取得』には配列を指定する必要があります。') }
+      const res = a.map(row => row[i])
+      return res
+    }
+  },
+  '表列挿入': { // @二次元配列Aの(0から数えて)I列目に配列Sを挿入して返す // @ひょうれつそうにゅう
+    type: 'func',
+    josi: [['の'], ['に', 'へ'], ['を']],
+    pure: true,
+    fn: function(a: any, i: any, s: any) {
+      if (!(a instanceof Array)) { throw new Error('『表列挿入』には配列を指定する必要があります。') }
+      const res: any[] = []
+      a.forEach((row, idx) => {
+        let nr: any[] = []
+        if (i > 0) { nr = nr.concat(row.slice(0, i)) }
+        nr.push(s[idx])
+        nr = nr.concat(row.slice(i))
+        res.push(nr)
+      })
+      return res
+    }
+  },
+  '表列削除': { // @二次元配列Aの(0から数えて)I列目削除して返す // @ひょうれつそうにゅう
+    type: 'func',
+    josi: [['の'], ['を']],
+    pure: true,
+    fn: function(a: any, i: any) {
+      if (!(a instanceof Array)) { throw new Error('『表列削除』には配列を指定する必要があります。') }
+      const res: any[] = []
+      a.forEach((row) => {
+        const nr = row.slice(0)
+        nr.splice(i, 1)
+        res.push(nr)
+      })
+      return res
+    }
+  },
+  '表列合計': { // @二次元配列Aの(0から数えて)I列目を合計して返す。 // @ひょうれつごうけい
+    type: 'func',
+    josi: [['の'], ['を', 'で']],
+    pure: true,
+    fn: function(a: any, i: any) {
+      if (!(a instanceof Array)) { throw new Error('『表列合計』には配列を指定する必要があります。') }
+      let sum = 0
+      a.forEach((row) => { sum += row[i] })
+      return sum
+    }
+  },
+  '表曖昧検索': { // @二次元配列AのROW行目からCOL列目(0起点)で正規表現Sにマッチする行を検索して何行目にあるか返す。見つからなければ-1を返す。(v1非互換) // @ひょうあいまいけんさく
+    type: 'func',
+    josi: [['の'], ['から'], ['で'], ['を']],
+    pure: true,
+    fn: function(a: any, row: any, col: any, s: any) {
+      if (!(a instanceof Array)) { throw new Error('『表曖昧検索』には配列を指定する必要があります。') }
+      const re = new RegExp(s)
+      for (let i = row; i < a.length; i++) {
+        const line = a[i]
+        if (re.test(line[col])) { return i }
+      }
+      return -1
+    }
+  },
+  '表正規表現ピックアップ': { // @二次元配列AでI列目(0起点)から正規表現パターンSにマッチする行をピックアップして返す。 // @ひょうせいきひょうげんぴっくあっぷ
+    type: 'func',
+    josi: [['の', 'で'], ['から'], ['を']],
+    pure: true,
+    fn: function(a: any, col: any, s: any) {
+      if (!(a instanceof Array)) { throw new Error('『表正規表現ピックアップ』には配列を指定する必要があります。') }
+      const re = new RegExp(s)
+      const res = []
+      for (let i = 0; i < a.length; i++) {
+        const row = a[i]
+        if (re.test(row[col])) { res.push(row.slice(0)) }
+      }
+      return res
+    }
+  },
+}