「カッコで囲う」を編集中 (節単位)

=== ソースコード ===
<syntaxhighlight lang="javascript" style="height:80em; overflow:auto;">
#title = "カッコ ..."
#tooltip = "カッコで囲う (ポップアップメニュー）"
#icon = "brackets(parenthesis)[2].ico"
// #icon = "Mery用 マテリアルデザインっぽいアイコン.icl",255

/**
 * -----------------------------------------------------------------------------
 * カッコで囲う(ポップアップメニュー）
 * sukemaru, 2018-08-24 - 2020-06-23
 * -----------------------------------------------------------------------------
 * (Last modified: 2020-06-23)
 * 	マルチカーソル／複数選択範囲に対応
 * 	入力ダイアログを使用する処理を関数化
 * 	カッコの定義配列の変数名を変更（p1 ⇒ pp1, p1 ⇒ pp1）
 * (2020-06-03)
 * 	カッコで囲まれた文字列が2つできてしまう不具合を修正
 * 	処理コード内の一部の変数名を変更
 * -----------------------------------------------------------------------------
 */

// ---------- ▼ 設定項目 ▼ ---------- //

// ■「任意の文字列２」と、wiki 文字装飾タグで、複数行の選択範囲内の空白行をスキップするか？
var skip = true;	// （true; スキップする ／ false; スキップしない）

// 「任意の文字列」で入力した文字列の一時記憶方法
var tagType = 2;
  // 0 ： 一時記憶なし
  // 1 ： タブ（文書）ごとに一時記憶する（Document.Tag）
  // 2 ： ウインドウごとに一時記憶する（Editor.Tag）
  // 3 ： すべてのタブとウインドウ共通で一時記憶する（window.Tag）


// ■開きカッコを配列で定義する
var pp1 = [ "" ,		// 以下 r = 1～10、11～20、21～ の ID 順
  "(" ,  "<" ,  "[" ,  "{" ,  "（" ,  "「" ,  "『" ,  "【" ,  " （" ,  " (" ,
  " \"" ,  " " ,  " - " ,  "――" ,  "～" ,  "'''" ,  "''" ,  "<u>" ,  "[[" , "<nowiki>" ,
  "" , "" , "" , "" , ""
];

// ■閉じカッコを配列で定義する
var pp2 = [ "" ,		// 以下 1～10、11～20、21～ の ID 順
  ")" ,  ">" ,  "]" ,  "}" ,  "）" ,  "」" ,  "』" ,  "】" ,  "） " ,  ") " ,
  "\" " ,  " " ,  " - " ,  "――" ,  "～" ,  "'''" ,  "''" ,  "</u>" ,  "]]" , "</nowiki>" ,
  "" , "" , "" , "" , ""
];

// ---------- ▲ 設定項目 ▲ ---------- //


var m = CreatePopupMenu();
var d = editor.ActiveDocument;
if ( d.ReadOnly ) {
  m.Add( "　ドキュメントは 書き換え禁止 です & ", 0 );
}

else {
  var s = editor.ActiveDocument.selection;
  var grayFlag = s.Text ? 0 : meMenuGrayed;

  // m.Add( "ラベル", r ); の各行は、任意に上下移動（並べ替え）してよいが、
  // r の数値は上の配列の並び順やテキスト変換処理の case r: に対応しているので変更しないこと！

  /* 入力 ダイアログ */
  m.Add( "任意の文字列 で前後を囲う (&E) ...", 1050 );	// Enter the custom string(s)
  m.Add( "任意の文字列 ２ （各行） (&F) ...", 1051 );	// 各行ごとに指定文字列で囲う（skip フラグを指定すること）

  /* 削除系コマンド */
  if ( s.Text ) {	// 選択範囲がないときは表示しない
    m.Add( "", 0, meMenuSeparator );
    m.Add( "▲ ひとつ削除 (&1)", 1038 );
    m.AddPopup( "● 削除 (&T)", sm1 = CreatePopupMenu() );
      sm1.Add( "　　先頭／末尾から任意の 文字列 を削除 （各行） (&Z) ...", 1052 );
      sm1.Add( "　　先頭／末尾から任意の 文字数 を削除 （各行） (&X) ...", 1053 );
      sm1.Add( "", 0, meMenuSeparator );
      sm1.Add( "≫ 先頭／末尾から 空白 を削除 ≪ （各行） (&W)", 1037 );
      sm1.Add( "≫ 先頭の 空白 を削除　　 （各行） (&T)", 1035 );
      sm1.Add( "　　末尾の 空白 を削除 ≪ （各行） (&B)", 1036 );
      sm1.Add( "", 0, meMenuSeparator );
      sm1.Add( "◀  1文字ずつ 前後を削除  ▶ （外側） (&0)", 1034 );
      sm1.Add( " ▶ &1文字ずつ前後を削除 ◀  (１)", 1031 );
      sm1.Add( " ▶ &2文字ずつ前後を削除 ◀  (２)", 1032 );
      sm1.Add( " ▶ &3文字ずつ前後を削除 ◀  (３)", 1033 );
  }

  /* カッコ */
  m.Add( "", 0, meMenuSeparator );
  m.Add( " ( 半角 小カッコ )  (&P)", 1 );       // Parenthesis
  m.Add( "", 0, meMenuSeparator );
  m.Add( "< 半角 山カッコ > (&A)", 2 );         // Angle brackets
  m.Add( " [ 半角 大カッコ ]  (&B)", 3 );       // square Brackets
  m.Add( " { 半角 中カッコ }  (&C)", 4 );       // Curly brackets

  m.Add( "", 0, meMenuSeparator );
  m.Add( "（ 全角 小カッコ ） (&R)", 5 );       // Round brackets
  m.Add( "", 0, meMenuSeparator );
  m.Add( "「 全角 かぎカッコ 」 (&K)", 6 );     // Kakko
  m.Add( "『 全角 二重かぎカッコ 』 (&W)", 7 ); // White corner brackets
  m.Add( "【 全角 スミ付きカッコ 】 (&L)", 8 ); // Lenticular brackets

  m.Add( "", 0, meMenuSeparator );
  m.Add( "␣（ 全角 小カッコ ）␣ (&F)", 9 );     // Full width parenthesis (w/ space)
  m.Add( "␣ ( 半角 小カッコ ) ␣ (&H)", 10 );    // Half-width parenthesis (w/ space)
  m.Add( '␣ "  半角 引用符  " ␣ (&Q)', 11 );    // double-Quotation mark (w/ space)
  m.Add( "␣  半角 スペース  ␣ (&S)", 12 );      // Space

  m.Add( "", 0, meMenuSeparator );
  m.Add( "  -   半角 ハイフン   -   (&-)", 13 );    // hyphen-minus  (w/ spaces)
  m.Add( "―― 全角 ダッシュ ―― (&D)", 14 );      // Dash
  m.Add( "～ 全角 チルダ ～ (&T)", 15 );            // Tilde

  /* JS コメントアウト ／ XML コメントアウト */
//   m.Add( "", 0, meMenuSeparator );
//   m.Add( "/* *  JS コメントアウト ２  */ (&J)", 1041 );  // JavaScript comment out (block comment)
//   m.Add( "/*  JS コメントアウト １  */ (&V)", 1042 );    // jaVascript comment out
//   m.Add( "▲  JS  アンコメント (&U)", 1043, grayFlag );  // Uncomment
//   m.Add( "", 0, meMenuSeparator );
//   m.Add( "<!--  XML コメントアウト  --> (&X)", 1044 );   // Xml comment out
//   m.Add( "▲  XML アンコメント (&M)", 1045, grayFlag );  // xMl uncomment

  /* wiki マークアップ
     このブロックの項目は、複数行を選択しているとき「選択範囲の各行ごとに囲う」処理をおこなう
    ※ skip フラグを指定すること */
//   m.Add( "", 0, meMenuSeparator );
//   m.AddPopup( "wiki 文字修飾 （各行） (&W)", sm2 = CreatePopupMenu() );
//     sm2.Add( "'''  wiki 太字  '''  (&B)", 16 );      // Bold
//     sm2.Add( "''   wiki 斜体   ''  ( &I )", 17 );    // Italic
//     sm2.Add( "<u> wiki 下線 </u>  (&U)", 18 );       // Under line
//     sm2.Add( "[[   wiki リンク   ]]  (&L)", 19 );    // Link
//     sm2.Add( "<nowiki>  </nowiki>  (&N)", 20 );      // Nowiki

  /* Mery マクロ用
     以下の項目は、選択範囲の文字列をコピーして、一行下でそれぞれの構文で囲う */
//   m.Add( "", 0, meMenuSeparator );
//   m.AddPopup( "Mery マクロ (&Y)", sm3 = CreatePopupMenu() );
//     sm3.Add( "アウトプット (&O)", 1060 );        // OutputBar.Writeln( ... )
//     sm3.Add( "アラート (&A)", 1061 );            // Alert( ... )
//     sm3.Add( "コンファーム (&C)", 1062 );        // Confirm( ... )
//     sm3.Add( "ステータス (&S)", 1063 );          // Status = ...

  m.Add( "", 0, meMenuSeparator );
  m.Add( "キャンセル\t& ", 0 );
}

// ポップアップメニューを表示
// m.Track(0); ならキャレット位置、m.Track(1); ならカーソル位置にポップアップ
var r = m.Track( mePosMouse = 1 );	// 選択されたメニュー項目のIDを r に格納する


if ( r > 0 ) {
  Redraw = false;

// ---------- ▼ マルチカーソル／複数選択範囲対応 ▼ ---------- //

  var tagKey = "AddBrackets2";
  var p, p1, p2;
  if ( r === 1050 || r === 1051 ) {	// 「任意の文字列を追加」
    p = Brackets2Prompt( tagType, tagKey );
    p1 = p.p1;  p2 = p.p2;
  }
  else if ( r === 1052 ) {			// 「任意の文字列を削除」
    p = DelStrPrompt( tagType, tagKey );
    p1 = p.p1;  p2 = p.p2;
  }
  else if ( r === 1053 ) {			// 「任意の文字数を削除」
    p = DelByNumPrompt();
    p1 = p.p1;  p2 = p.p2;
  }
  else {
    p1 = pp1[r];  p2 = pp2[r];
  }

  if ( p1 || p2 || r > 1000 ) {
    // マルチカーソル／複数選択に対応
    var arg = [ r, p1, p2, skip ];
    // 選択範囲が１つで矩形選択ではないとき
    if ( ! s.Mode || s.Mode === meModeStream ) {
      AddBrackets_Main( arg );
    }
    // 矩形選択または複数選択のとき
    else {
      var sx = ScrollX,  sy = ScrollY;
      BeginUndoGroup();
      AddUndo();
      MultiFunction( AddBrackets_Main, arg );
      EndUndoGroup();
      ScrollX = sx;  ScrollY = sy;
    }
  }

  Redraw = true;
}

/**
 * 関数 function AddBrackets_Main( [ r, p1, p2, skip ] )
 * カッコで囲う(ポップアップメニュー）のメイン処理
 */
function AddBrackets_Main( arg ) {
  var r    = arg[0];
  var p1   = arg[1];
  var p2   = arg[2];
  var skip = arg[3];

  // マクロ実行前の選択範囲の各座標を取得
  var d = editor.ActiveDocument,  s = d.selection;
  var anc = s.GetAnchorPos(),  act = s.GetActivePos();
  var tp = ( anc < act ) ? anc : act;
  var bp = ( anc < act ) ? act : anc;
  // 選択範囲がなければカーソル位置を取得
  if ( s.IsEmpty ) {
    var pos = s.GetActivePos();
  }
  var tx = s.GetTopPointX( mePosLogical );
  var ty = s.GetTopPointY( mePosLogical );
  var bx = s.GetBottomPointX( mePosLogical );
  var by = s.GetBottomPointY( mePosLogical );
  // 選択範囲の末尾位置を調整（最後の \n を含めない）
  // ※ { 中カッコ } のばあいは末尾の調整をしない
  if ( ! s.IsEmpty && bx == 1 && r != 4 ) {
    s.SetActivePos( bp - 1 );
    s.SetAnchorPos( tp );
  }

  // 選択範囲の文字列を取得
  var st = tmp = s.Text;

  // IDごとのテキスト変換処理
  switch ( r ) {

  // カッコ
  case 1:  case 2:  case 3:  case 4:  case 5:  case 6:
  case 7:  case 8:  case 9:  case 10:  case 11:  case 12:
  case 21:  case 22:  case 23:  case 24:  case 25:
    // カッコ p1 ＆ p2 で囲う
    s.Text = p1 + st + p2;
    // 選択範囲があれば選択範囲を復元
    if ( st ) { s.SetAnchorPos( tp ); }
    // 選択範囲がなければカーソルをカッコのなかに移動
    else { s.SetActivePos( pos + p1.length ); }
    break;

  // ハイフン、ダッシュ、チルダ
  case 13:  case 14:  case 15:
    // 選択範囲があればダーシ p1 ＆ p2 で囲う
    if ( st ) {
      s.Text = p1 + st + p2;
      s.SetAnchorPos( tp );	// 選択範囲を復元
    }
    // 選択範囲がなければ片側分 p1 だけ挿入
    else { s.Text =  p1; }
    break;

  // wiki 文字装飾タグ	※ 太字／斜体／下線／<nowiki>
  // 選択範囲内の「各行を囲う」処理をおこなう。
  // 複数行選択で空白行をスキップするかは冒頭の skip フラグで決定する。
  // 選択範囲なしで実行するとタグの間がわかりづらくなるので全角スペースを挿入する。
  case 16:  case 17:  case 18:  case 20:
    // 選択範囲があれば各行を p1 ＆ p2 で囲う
    if ( st ) {
      tmp = AddBrackets( st, p1, p2, skip );
      if ( tmp != st ) {
        s.Text = tmp;
        s.SetAnchorPos( tp );	// 選択範囲を復元
      }
      else {	// テキストに変更なしなら選択範囲の復元だけ
        s.SetActivePos( act );  s.SetAnchorPos( anc );
      }
    }
    // 選択範囲がなければ p1 ＆ p2 と全角スペースを挿入
    else {
      s.Text = p1 + "　" + p2;
      s.SetAnchorPos( pos + p1.length );			// カーソルをタグのなかに移動
      s.SetActivePos( s.GetAnchorPos() + 1, true );	// 全角スペースを範囲選択
    }
    break;

  // wiki 文字装飾		※ 内部リンク用タグ	[[リンク|ラベル]]
  // 選択範囲内の「各行を囲う」処理をおこなう。
  // 複数行選択で空白行をスキップするかは冒頭の skip フラグで決定する。
  case 19:
    // 選択範囲があれば各行を [[str|str]] に変換
    if ( st ) {
      var tmp = AddWikiLink( st, p1, p2, skip );
      if ( tmp != st ) {
        s.Text = tmp;
        s.SetActivePos( tp + p1.length );	// p1 の後ろにカーソルを移動
      }
      else {	// テキストに変更なしなら選択範囲の復元だけ
        s.SetActivePos( act );  s.SetAnchorPos( anc );
      }
    }
    // 選択範囲がなければ p1 ＆ p2 と " | " を挿入
    else {
      s.Text = p1 + "　|　" + p2;
      s.SetActivePos( pos + p1.length );			// カーソルをカッコの中に移動
      s.SetAnchorPos( s.GetActivePos() + "　|　".length );	// カッコの中を範囲選択
    }
    break;

  // n文字ずつ前後を削除（内）
  case 1031:  case 1032:  case 1033:
    if ( st ) {
      // 選択範囲の両端から n 文字ずつ消す
      var n = ( r - 1030 );
      s.Text = st.slice( n, st.length - n );
      s.SetAnchorPos( tp );	// 選択範囲を復元
    }
    break;

  // １文字ずつ前後を削除（外）
  case 1034:
    s.SetAnchorPos( tp - 1 );			// 選択範囲の先頭側を１文字拡張
    s.SetActivePos( bp + 1, true );		// 選択範囲の末尾側を１文字拡張
    s.Text = s.Text.slice( 1, - 1 );	// 先頭/末尾を１文字ずつ削除
    s.SetAnchorPos( tp - 1 );			// 選択範囲を復帰する
    break;

  // 行頭／行末の空白を削除	※選択範囲を論理行単位に拡張はしない
  case 1035:  case 1036:  case 1037:
    if ( st ) {
      tmp = ( r == 1037 ) ? st.replace( /^[\t 　]*|[\t 　]*$/gm , "" ) :	// 行頭／行末
            ( r == 1035 ) ? st.replace( /^[\t 　]*/gm , "" ) :	// 行頭
           /* r == 1036 */  st.replace( /[\t 　]*$/gm , "" ) ;	// 行末

      // 選択範囲に指定文字列がなかった場合 undo 履歴を残さない
      if ( tmp != st ) {
        s.Text = tmp;			// 削除完了
        s.SetAnchorPos( tp );	// 選択範囲を復元
      }
    }
    break;

  // ひとつ削除 （※「カッコをはずす」マクロのコードを流用）
  case 1038:
    // 「ひとつ削除」用のカッコの定義
    var brackets = "  ()｢｣<>[]{}\"\"''"
    + "（）「」『』＜＞［］｛｝【】〖〗⦅⦆｟｠〚〛〔〕〘〙〈〉《》"
    + "””’’〝〞〝〟‘’“”――～～〜〜"
    + "++--**\/\/##==%%::：：@@＠＠※※††｜｜……␣␣＿＿"
    + "○○●●□□■■◇◇◆◆▽▽▼▼△△▲▲☆☆★★"
    + "←→→←↑↓↓↑←←→→↑↑↓↓"
    + "¿?¡!‚‘‚’„“„”“„‘‚‹››‹«»»«——‐‐－－"
    + "﹁﹂﹃﹄︵︶︿﹀︽︾︹︺︷︸︻︼︗︘";
    var brackets2 = [
      "<b>", "</b>" , "<i>", "</i>" , "<u>", "</u>" , "<s>", "</s>" ,
      "</", ">" , "<", "/>" , "<!-- ", " -->" , "<!--", "-->" , 
      "/** \n", "\n */" , "/** \n", "\n*/" , "/**\n", "\n */" , "/**\n", "\n*/" , 
      "/* \n", "\n */" , "/* \n", "\n*/" , "/*\n", "\n */" , "/*\n", "\n*/" , 
      "/** ", " */" , "/**", " */" , "/* ", " */" , "/*", " */" , 
      "'''''", "'''''" , "'''", "'''" , "''", "''" , "[[", "]]" ,  
      "<nowiki>", "</nowiki>" , "<span>", "</span>" , "<div>", "</div>" , 
      "<pre>", "</pre>" , "<source lang=\"javascript\">", "</source>" 
    ];
    brackets = brackets2.concat( brackets.split( "" ) );

    tmp = DeleteBrackets( st, brackets );
    if ( st != tmp ) {
      s.Text = tmp;
      s.SetAnchorPos( tp );	// 選択範囲を復帰する
    }
    else {	// テキストに変更なしなら選択範囲の復元だけ
      s.SetActivePos( act );  s.SetAnchorPos( anc );
    }
    break;

  // /* * JavaScriptコメントアウト ２ */
  case 1041:
/*
 *   基本的に１行めが行の先頭から始まることしか想定していないので、
 *   あらかじめコメントアウトする文字列は、行単位でまとまったブロックにしておくとよい。
 *   選択範囲の先頭／末尾が行の途中にある状態でコメントアウトする場合は、改行を追加する。
 */

    p1 = ( tx > 1 ) ? "\n/\*\n" : "/\*\n";
    p2 = ( document.Text.charAt( bp ) != "\n" ) ? "\n */\n" : "\n */";
    var ast = " * ";
    // 選択範囲の先頭座標が x = 1 でなければ改行させるので選択範囲の復元用座標を調整
    if ( tx > 1 ) { tp ++; }

    // コメントアウト
//    s.Text = CommentOutJS( st, p1, p2, ast );	// コメントアウト（関数バージョン）
    /*  ※ JS コメントアウト の正規表現置換バージョンの検証は不十分 ※ */ 
    s.Text = p1 + st.replace( /^(.*)$/gm, ast + "$1" ) + p2;

    // 選択範囲があれば選択範囲を復元
    if ( st ) { s.SetAnchorPos( tp ); }
    // 選択範囲がなければカーソルをコメント枠のなかに移動
    else { s.SetActivePos( s.GetActivePos() - p2.length ); }
    break;

  /* JavaScript コメントアウト １ */
  // <!-- XML コメントアウト --> 
  case 1042:  case 1044:
    /* JavaScript コメントアウト １ */
    if ( r == 1042 ) { p1 = " /\* ";  p2 = " */ "; }
    // <!-- XML コメントアウト --> 
    else { p1 = " <!-- ";  p2 = " --> "; }
    s.Text = p1 + st + p2;
    // 選択範囲があれば選択範囲を復元
    if ( st ) { s.SetAnchorPos( tp ); }
    // 選択範囲がなければカーソルをコメント枠のなかに移動
    else { s.SetActivePos( pos + p1.length ); }
    break;

  // JS アンコメント:
  // case 1041 と case 1042: の /* JavaScriptコメント */ をアンコメントする。
  // 選択範囲内の各行頭のコメントマーク "/* "  と " * " と " */" のみマッチ。
  // 「カッコで囲う」では行の先頭部分のコメントマークだけにしかマッチしないので、
  // コメント部分がインデントされている場合は「引用符／コメント」マクロのJSアンコメントを使うこと。
/* 
 * ・選択範囲に複数のコメントブロックがある場合を想定していない。
 * ・中間行の行頭記号はアスタリスク「 * 」、全角中黒「・」、半角中黒「･」を削除対象とする。
 *   （行頭記号と前後の半角スペース各１を削除する）
 * ・JSコメントでない箇条書き文で実行した場合も行頭のビュレット「* ・ ･」を削除する。
 */
/* このタイプのコメントにたいしてもアンコメント処理する。 */

  // XML アンコメント:
  // case 1044 の <!-- XMLコメント --> をアンコメントする。
  // 選択範囲の先頭の " <!-- " と 末尾の " --> " のみマッチ。
  // 選択範囲に複数のコメントがあると正常にアンコメントしない。

  case 1043:  case 1045:
    // 選択範囲の先頭と末尾のコメントマークを削除
//    if ( r == 1043 ) {
//      // JS アンコメント（関数バージョン）
//      tmp = UnCommentJS( st );
//    }
    /*  ※ JS アンコメントの正規表現置換バージョンの検証は不十分 ※ */ 
    // JS アンコメント（正規表現バージョン）
    if ( r == 1043 ) {
      tmp = st.replace( /^ ?\/\*+ ?\n?|\n? ?\*+\/ ?$/gm, "" )
              .replace( /^ ?(?:\*+|[・･]) ?/gm, "" );
    }
    // XML アンコメント
    else {	// ( r == 1045 )
      tmp = st.replace( /^ ?<!-+ ?| ?-+ *>\ ?$/g, "" );
    }
    // 選択範囲にコメントマークがなかった場合 undo 履歴を残さない
    if ( tmp == st ) {		// テキストに変更なしなら選択範囲の復元だけ
      s.SetActivePos( act );  s.SetAnchorPos( anc );
    }
    else {
      s.Text = tmp;			// アンコメント完了
      s.SetAnchorPos( tp );	// 選択範囲を復元
    }
    break;

  // 任意の文字列を追加	※テキストボックス
  case 1050:  case 1051:
    if ( p1 || p2 ) {
      if ( st ) {
        // 「任意の文字列１」	選択範囲全体を p1 ＆ p2 で囲う
        if ( r == 1050 ) {
          s.Text = p1 + st + p2;
        }
        // 「任意の文字列２」	選択範囲の各行を p1 ＆ p2 で囲う
        else {
          tmp = AddBrackets( st, p1, p2, skip );
          if ( tmp != st ) { s.Text = tmp; }
          else { s.SetActivePos( bp ); }
        }
        s.SetAnchorPos( tp );	// 選択範囲を復元
      }
      // 選択範囲がなければ p1 ＆ p2 を挿入し、カーソルをカッコのなかに移動
      else {
        s.Text = p1 + p2;
        s.SetActivePos( pos + p1.length );
      }
    }
    break;

  // 各行の前後から任意の文字数／文字列を削除	※テキストボックス
  case 1052:  case 1053:
    if ( st ) {
      // 「任意の文字数を削除」	各行の先頭/末尾から指定文字数を削除
      if ( r == 1053 ) {
        tmp = DeleteCharByNum( st, p1, p2 );
      }
      // 「任意の文字列を削除」	各行の先頭/末尾の指定文字列を削除
      else {	// ( r == 1052 )
        var reg = new RegExp(
          "^" + p1.replace( /[.*+?^=!:${}()|[\]\/\\]/g, "\\$&" )
        + "|" + p2.replace( /[.*+?^=!:${}()|[\]\/\\]/g, "\\$&" ) + "$"
        , "gm" );
        tmp = st.replace( reg , "" );
      }
      // 選択範囲に指定文字列がなかった場合 undo 履歴を残さない
      if ( tmp != st ) {
        s.Text = tmp;			// 削除完了
        s.SetAnchorPos( tp );	// 選択範囲を復元
      }
    }
    break;

  // アウトプット ／ アラート ／ コンファーム ／ ステータス
  /**
   * 選択範囲の文字列 st をコピーして、１行下に
   * OutputBar.Writeln( "st" );
   * Alert( "st" );
   * Confirm( "st" );
   * Status = "st";
   * の行を追加する
   * → 追加した行の移動は「行を上/下に移動」マクロで
   * → 引用符がジャマなら「引用符で囲う」マクロで除去を…
   */
  case 1060:  case 1061:  case 1062:  case 1063:
    s.SetActivePoint( mePosLogical, 1, by + 1 );
    // 選択範囲が複数行なら +"\n"+ でつなぐ
    tmp = '"' + st.replace( /\n/g, '" + "\\n" + "' ) + '"';
    var sur = ( ( r == 1063 ) ? ";" : " );" ) + "\n";
    s.Text  = ( ( r == 1060 ) ? "OutputBar.Writeln( " :
                ( r == 1061 ) ? "Alert( " :
                ( r == 1062 ) ? "Confirm( " :
               /* r == 1063 */  "Status = "
              ) + tmp + sur;
    // カッコの中の文字列を範囲選択する
    s.SetActivePos( s.GetActivePos() - sur.length );
    s.SetAnchorPos( s.GetActivePos() - tmp.length );
    // アウトプットの場合は、アウトプットバーを表示
    if ( r == 1060 ) {
      ScrollY = s.GetActivePointY( mePosView );
      OutputBar.Visible = true;
    }
    break;

  default:
    break;
  }
}


/* 関数 AddBrackets( str, p1, p2, skip ) */
function AddBrackets( str, p1, p2, skip ) {
  var a = str.split( "\n" );	// 選択範囲 st を "\n" で区切って配列 a に
  for ( var i = 0, len = a.length; i < len; i ++ ) {
    // skip = true のときは、空白行をスキップ
    if ( str && skip && /^\s*$/.test( a[i] ) ) { continue; }
    // 空行にカッコを挿入する場合は全角スペースをはさむ
    var space = ( ( p1.length && p2.length ) && ( ! str || ! a[i].length ) )
              ? "　" : "" ;
    a[i] = p1 + space + a[i] + p2;	// 各行をカッコ p1 ＆ p2 で囲う
  }
  return a.join( "\n" );
}


/* 関数 AddWikiLink( str, p1, p2 skip ) */
function AddWikiLink( str, p1, p2, skip ) {
  var a = str.split( "\n" );		// 選択範囲 st を "\n" で区切って配列 a に
  for ( var i = 0, len = a.length; i < len; i ++ ) {
    // skip = true のときは、空白行をスキップ
    if ( str && skip && /^\s*$/.test( a[i] ) ) { continue; }
    // 空行には全角スペースつきではさむ
    var bar = ( ! str || ! a[i].length ) ? "　|　" : "|" ;
    a[i] =  p1 + a[i] + bar + a[i] + p2;	// 各行を [[str|str]] に置換
  }
  return a.join( "\n" );
}


/* 関数 DeleteCharByNum( st, p1, p2 ) */
function DeleteCharByNum( str, p1, p2 ) {
  var a = str.split( "\n" );
  for ( var i = 0, len = a.length; i < len; i ++ ) {
    // 各行の先頭/末尾からの指定文字数を削除
    a[i] = a[i].slice( p1, a[i].length - p2 );
  }
  return a.join( "\n" );
}


/* 関数 DeleteBrackets( str, brackets ) */
// 選択範囲の先頭と末尾から１組のカッコを削除する
function DeleteBrackets( str, brackets ) {
  // ループ処理で「対になるカッコ」と一致するかチェック
  for ( var i = 0, len = brackets.length; i < len; i ++ ) {
    if ( i % 2 == 1 || ! brackets[i].length ) { continue; }
    var o = brackets[ i ];		// 開きカッコ
    var c = brackets[ i + 1 ];	// 閉じカッコ

    // 選択範囲内の先頭と末尾が「対になるカッコ」のとき
    if ( str.length >= o.length + c.length
    && str.slice( 0, o.length ) == o
    && str.slice( - c.length ) == c ) {
      str = str.slice( o.length, - c.length );	// 先頭/末尾のカッコを削除
      break;
    }
  }
  return str;
}


/**
 * 関数 ToHalfWidth( strVal )
 * 全角英数記号を半角変換して返す
 */
function ToHalfWidth( strVal ){
  // 半角変換（文字コードをシフト）
  return strVal.replace( /[！-～]/g, function( tmpStr ) {
    return String.fromCharCode( tmpStr.charCodeAt(0) - 0xFEE0 );
  } );
}


/**
 * 関数 GetTag( tagType, tagKey, property )
 * 指定された Tag の値を返す
 */
function GetTag( tagType, tagKey, property ) {
  try {
    var obj = ( typeof tagType === "object" ) ? tagType
            : ( tagType === 1 ) ? editor.ActiveDocument
            : ( tagType === 2 ) ? editor
            : ( tagType === 3 ) ? window
            : window;
    return ( obj.Tag.Exists( tagKey )
    && ( property ? property in obj.Tag( tagKey ) : true ) )
    ? property
      ? obj.Tag( tagKey )[ property ]
      : obj.Tag( tagKey )
    : null;
  } catch( e ) { Status = e;  return null; }
}


/**
 * 関数 SetTag( value, tagType, tagKey, property )
 * 指定された値を Tag に書き込む
 */
function SetTag( value, tagType, tagKey, property ) {
  try {
    var obj = ( typeof tagType === "object" ) ? tagType
            : ( tagType === 1 ) ? editor.ActiveDocument
            : ( tagType === 2 ) ? editor
            : ( tagType === 3 ) ? window
            : window;
    if ( property ) {
      if ( obj.Tag.Exists( tagKey ) ) {
        obj.Tag( tagKey )[ property ] = value;
      }
      else { obj.Tag( tagKey ) = { property: value }; }
    }
    else { obj.Tag( tagKey ) = value; }
  }
  catch( e ) { Status = e; }
  finally { return; }
}


/**
 * 関数 Brackets2Prompt( tagType, tagKey )
 * 「任意の文字列」コマンド
 * 開きカッコと閉じカッコ
 * 入力ダイアログで指定された文字列を返す
 */
function Brackets2Prompt( tagType, tagKey ) {
  // 前回使用した文字列があればダイアログの初期値に再利用
  var str1 = str2 = "";
  if ( tagType && ( t = GetTag( tagType, tagKey, "addStr" ) ) ) {
    str1 = t.str1;  str2 = t.str2;
  }
  // 入力ダイアログ
  var msg = "につける文字列:\t"
          + "改行 = \\\\\\ｎ ; タブ = \\\\\\ｔ  (注:￥記号３つ)";
  p1 = Prompt( "前" + msg, str1 ).replace( /\\\\\\t/g, "\t" )
                                 .replace( /\\\\\\n/g, "\n" );
  p2 = Prompt( "後ろ" + msg, str2 ).replace( /\\\\\\t/g, "\t" )
                                   .replace( /\\\\\\n/g, "\n" );
  if ( ! p1 && ! p2 ) { return { p1: "",  p2: "" }; }
  if ( tagType ) {
    var value = {
      str1: p1.replace( /\t/g, "\\\\\\t" ).replace( /\n/g, "\\\\\\n" ),
      str2: p2.replace( /\t/g, "\\\\\\t" ).replace( /\n/g, "\\\\\\n" )
    }
    SetTag( value, tagType, tagKey, "addStr" );
  }
  return { p1: p1, p2: p2 };
}


/**
 * 関数 DelStrPrompt( tagType, tagKey )
 * 「任意の文字列を削除」コマンド
 * 開きカッコと閉じカッコ
 * 入力ダイアログで指定された文字列を返す
 */
function DelStrPrompt( tagType, tagKey ) {
  // 前回使用した文字列があればダイアログの初期値に再利用
  var str1 = str2 = "";
  if ( tagType && ( t = GetTag( tagType, tagKey, "delStr" ) ) ) {
    str1 = t.str1;  str2 = t.str2;
  }
  // 入力ダイアログ
  var msg = "から削除する文字列:\t"
          + "タブ = \\\\\\ｔ  (注:￥記号３つ)";
  p1 = Prompt( "先頭（行頭）" + msg, str1 ).replace( /\\\\\\t/g, "\t" );
  p2 = Prompt( "末尾（行末）" + msg, str2 ).replace( /\\\\\\t/g, "\t" );
  if ( ! p1 && ! p2 ) { return { p1: "",  p2: "" }; }
  if ( tagType ) {
    var value = {
      str1: p1.replace( /\t/g, "\\\\\\t" ),
      str2: p2.replace( /\t/g, "\\\\\\t" )
    }
    SetTag( value, tagType, tagKey, "delStr" );
  }
  return { p1: p1, p2: p2 };
}


/**
 * 関数 DelByNumPrompt()
 * 「任意の文字列を削除」コマンド
 * 入力ダイアログで指定された文字列から
 * 数字を抽出して半角数字にして返す
 */
function DelByNumPrompt() {
  // ダイアログのテキスト入力フィールドから文字列を取得
  var msg = "から削除する文字数 （数字のみ有効）:";
  var p1 = ToHalfWidth( Prompt( "先頭（行頭）" + msg, "" )
           ).replace( /\D/g , "" );	// 半角に変換して数字以外の文字は削除
  var p2 = ToHalfWidth( Prompt( "末尾（行末）" + msg, "" )
           ).replace( /\D/g , "" );	// 半角に変換して数字以外の文字は削除
  return { p1: p1, p2: p2 };
}


/**
 * 関数 MultiFunction( Fn, arg1 )
 * マルチカーソル（複数選択範囲）に対応させる
 * 第１引数: Function; 選択範囲ごとに適用する処理の関数
 * 第２引数以降: Function に渡す引数をまとめた配列
 */
function MultiFunction( Fn, arg ) {
  var d = editor.ActiveDocument;
  var s = d.selection;

  // 矩形選択範囲は行に分ける
  s.Mode = meModeMulti;

  // 選択範囲の座標を取得
  var sCount = s.Count;
  var Sel = [];
  for ( var i = 0; i < sCount; i ++ ) {
    Sel[i] = {
      act: s.GetActivePos( i ),
      anc: s.GetAnchorPos( i )
    };
  }

  // 各選択範囲を処理;
  for ( var i = 0, diff = 0, dl; i < sCount; i ++ ) {
    dl = d.TextLength;
    s.SetActivePos( Sel[i].act + diff );
    s.SetAnchorPos( Sel[i].anc + diff );

    Fn( arg );	// AddBrackets_Main() 関数を実行

    // Fn() の残した選択範囲（またはキャレット位置）を回収
    Sel[i].act = s.GetActivePos();
    Sel[i].anc = s.GetAnchorPos();
    diff += d.TextLength - dl;	// 文字数の増減量（累積）
  }

  // マルチカーソル（複数選択範囲）を復帰
  for ( var i = 0; i < sCount; i ++ ) {
    s.AddPos( Sel[i].anc, Sel[i].act );
  }
}
</syntaxhighlight>