変奏現実

wq string   =   (*$ NO SPACE SKIP $*) '"', /(?!\\\\)[^"]*/, '"' ;

wq string   =   '"' ・・・ '"' ;

const encloseParser = parser.enclose(parser.token('"'), parser.search('"', true));

/**
 * 記号で囲むリテラル用のパーサを作成する
 * @param {Function} leftParser   左囲みtoken
 * @param {Function} rightParser  右囲みsearch
 * @return {Function} 			  生成した連結パーサ
 */
enclose(leftParser, rightParser) {
  const methodName = 'enclose';
  const encloseParser = () => {
    const bkPosition = this.position;
    const leftParsed = leftParser();
    if (!leftParsed.status) {
      return new ParserResult(false, null, bkPosition);
    }
    const rightParsed = rightParser();
    if (!rightParsed.status) {
      return new ParserResult(false, null, bkPosition);
    }
    const encloseText = this.target.substring(leftParsed.position, rightParsed.position - rightParsed.result.length);
    return new ParserResult(true, encloseText, this.position);
  };
  encloseParser.type = methodName;
  return this.parserWraper(encloseParser;
};

/**
 * 一致するパターンを検索するパーサを生成する
 * yオプションを付けないregExpバージョン
 * @param {string} text       検索パターン
 * @param {boolean} fEscape   エスケープ処理
 * @return {Function}         生成したパーサ
 */
search(text, fEscape = undefined) {
  const methodName = 'token';
  const len = text.length;
  // エスケープ処理の指定が無い場合
  if (fEscape === undefined) { fEscape = this.fEscape; }
  const rePat = `(${(fEscape) ? '?<!\\\\)(' : ''}${regExpEscape(text)})`;
  const re = new RegExp(rePat, '');
  const searchParser = this.regexp(re, 'gm'); // yオプションを付けないregExpバージョン
  searchParser.type = methodName;
  return searchParser;  // regexpParserでparserWraper済
};

/**
  *  正規表現パーサを作成する
  * @param {RegExp} re  正規表現
  * @param {*} options  オプション  ※未設定の場合は、正規表現のオプション＋gmyオプション
  * @return {Function}  生成したパーサ
  */
regexp(re, options) { // g:lastIndexから開始、m:複数行、y:lastIndexでのみ判定
  const methodName = 'regexp';
  const source = re.source;
  if (options === undefined) {
    options = (re.hasIndices ? 'd' : '')
      + (re.global ? 'g' : 'g')     /* lastIndex利用が必須なため、常時gオプションを付加 */
      + (re.ignoreCase ? 'i' : '')
      + (re.multiline ? 'm' : 'm')  /* 改行を跨いで処理すたい場合もあるので、常時mオプションを付加 */
      + (re.dotAll ? 's' : '')
      + (re.unicode ? 'u' : '')
      + (re.unicodeSets ? 'v' : '')
      + (re.sticky ? 'y' : 'y')     /* regexpは index=0 のみ判定する方が都合が良いので、常時yオプションを付加 */
      ;
  }
  try {
    re = new RegExp(source, options);
  } catch (ex) {
    const msg = `${rgis.className}.${methodName}: new RegExp fail, ex:'${ex}'`;
    console.error(msg);
    throw new Error(msg);
  }
  /**
   *  生成した正規表現パーサ
   * @return {ParserResult}       パースした結果
   */
  const regexpParser = () => {/* regexp */
    re.lastIndex = this.position;                                       // 再利用時のため
    const result = re.exec(this.target);                        // とりあえず正規表現で実行
    if (result) {
      // 読取りに成功した場合
      const foundText = result[0];
      // ログに追記
      this.mapLog.addSuccessToken(foundText);
      // 読取り位置を更新
      this.position = result.index + foundText.length;
      return new ParserResult(true, foundText, this.position);
    } else {
      // 読取りに失敗した場合
      // ログに追記
      this.mapLog.addFailToken(source);
      return new ParserResult(false, null, this.position);
    }
  };
  regexpParser.type = methodName;
  return this.parserWraper(regexpParser, true, false);
};

    {
        title: "sequenceメソッド：正常パターン4",
        testCase: () => {
            const parser = new CoreParser('abc=defghijklmnopqrstuvwxyz')
            const sequenceParser1 = parser.sequence([parser.token('abc'), parser.token('='), parser.token('def')]);
            const rc = [];
            rc.push(sequenceParser1());
            return rc;
        },
        expectedResult: [
            { status: true, result: ['abc', '=', 'def'], position: 7, },
        ],
    },

test[4:sequenceメソッド：正常パターン4] success. => [ 0:{ "status": true, result:[ "0": "abc", "1": "=", "2": "def", ], "position": 7, }, ], 

[ 0:{ "status": true, result:[ "0": "abc", "1": "=", "2": "def", ], "position": 7, }, ], 

/'.*?'/
👉 / ' .* ? ' /          ※見やすいように空白を挟んでみた

'(.*?\\')*.*?'
👉 ' (.* ? \\' )* .* ? '　　　※見やすいように空白を挟んでみた

/ .* /
こんなザックリとした表現は意味は読み取れるけど使い物にならないが
👉　/ .* ? /
でちょっとは使えるので、
正規表現内で/が出現する状況を挟み込んで
👉　/ ((.* ? \/)|(.* ? [/)|(.* ?(/)|(.* ?{/))* .* ? /　　※ / に　４連の　(.* ?　を仕掛けるぞ（的な
で良いのかもしれない。
※とても十分な検証をする気にはならないががが

<body>
・・・
<input type="text" id="regexp_pattern" size="80" autocomplete="on" />
<input type="text" id="regexp_option" size="16" autocomplete="on" />
・・・
<input type="button" id="text_color_regexp_text" value="名前付きキャプチャグループ名で色付け" /></br>
結果：<div class="result" id="result"></div>
・・・
</body>

/**
 * サンプルコードのオブジェクトを作成
 */
const regExpSample = new class RegExpSample {
　・・・
  /**
   * 初期化
   * @memberof RegExpSample
   */
  setup = () => {
    // イベントリスナー登録
    ・・・
    document.querySelector('#text_color_regexp_text').addEventListener("click", this.textColorFromClickButton);
　　・・・
  };
　・・・
  /**
   * 【名前付きキャプチャグループ名で色付け】ボタンクリック処理
   * @memberof RegExpSample
   */
  textColorFromClickButton = () => {
    try {
      clearnHtmlObjectTextContent('result');
      // 結果を格納するdiv
      const divResult = document.querySelector('#result');
      // サンプル ※関数の引数の初期値に割り当てたら、画面初期表示時の空っぽだった件
      let text = document.querySelector('#regexp_text').value; //.replace('\r\n', '\n');
      // RegExpのパターンとオプションからRegExpクラスのオブジェクトを作成する
      const re = createRegexpPattern();
      // RegExpクラスのオブジェクトを渡しtextColorにお任せ
      let result = textColor(text, re);
      // 読み飛ばした箇所に背景色（黒）を付ける
      result = this.setBackColor(result);
      // textColorの結果を画面に出力
      result = result.replaceAll(/[\r\n]/g, '<br/>');
      divResult.innerHTML = result;
    } catch (ex) {
      console.error(`textColorFromClickButton : ${ex}`);
    }
  };
　・・・
};
// 初期化
window.addEventListener("load", () => {
  regExpSample.setup();
});

const date = () => {
    const date = new Date();
    return new Intl.DateTimeFormat("ja-JP-u-ca-japanese", {
        dateStyle: "full",        timeStyle: undefined,        timeZone: "Asia/Tokyo",
    }).format(date);
};
const time = () => {
    const date = new Date();
    return new Intl.DateTimeFormat("ja-JP-u-ca-japanese", {
        dateStyle: undefined,        timeStyle: "full",        timeZone: "Asia/Tokyo",
    }).format(date);
};
const test1 (type) => {
  let result = '';
    if(type==='date') { result = `${ date() }`;
    if(type==='time') { result = `${ time() }`};
  return result;
}
test1('date');
test1('time');

・・・
(type) => {
  let result = `
    ${(type==='date')? `${ date() }` : ''}
    ${(type==='time')? `${ time() }` : ''}
    `;
  return result;
}

`...${...`.....`...}..${...`.....`...}....`

# exmport:BQLITERAL
BQLITERAL:  ( ` ( '${'  |  '}'  | '.*' )*  ` )
# exmport:.

# main
COMMENT:    (/{2}.*$|\/\*\/?([^/]|[^*]\/|\r|\n)*\*\/)
・・・
BQLITERAL:  (`) # import(BQLITERAL)
 👈多分この部分は　RegExp.exec()の戻り値のgroupsにBQLITERALがあったら、サブルーチン呼び出しみたいな感じかな
# .

((\$\{)([^\}]*)(\}))

BQLITERAL:  (`(\\\\|\\`|[^`]|\r|\n)*`)

(new)BQLITERAL:  (`(((\${)([^\}]*)(\}))|(\\\\|\\`|[^`]|\r|\n))*`)

---`aaa${222`333444555`666}aaaa$bbbb${222`333444555`666}`---------
---`aaa${222`333${222`333444555`666}444555`666}aaaa$bbbb${222`333444555`666}`---------

・・・
[BQLITERAL] : '`aaa${222`'
[SYMBOLE] : '333444555'
[BQLITERAL] : '`666}aaaa$bbbb${222`'
[SYMBOLE] : '333444555'
[BQLITERAL] : '`666}`'
・・・
[BQLITERAL] : '`aaa${222`'
[SYMBOLE] : '333$'
[L_BRACE] : '{'
[SYMBOLE] : '222'
[BQLITERAL] : '`333444555`'
[SYMBOLE] : '666'
[R_BRACE] : '}'
[SYMBOLE] : '444555'
[BQLITERAL] : '`666}aaaa$bbbb${222`'
[SYMBOLE] : '333444555'
[BQLITERAL] : '`666}`'
・・・

・・・
[BQLITERAL] : '`aaa${222`333444555`666}aaaa$bbbb${222`333444555`666}`'
・・・
[BQLITERAL] : '`aaa${222`333${222`333444555`666}444555`'
・・・

---`aaa${222`333444555`666}aaaa$bbbb${222`333444555`666}`---------
---`aaa${222`333${222`333${222`333444555`666}444555`666}444555`666}aaaa$bbbb${222`333444555`666}`---------

・・・
[BQLITERAL] : '`aaa${222`333444555`666}aaaa$bbbb${222`333444555`666}`'
・・・
[BQLITERAL] : '`aaa${222`333${222`333${222`333444555`666}444555`'
・・・
[BQLITERAL] : '`666}aaaa$bbbb${222`333444555`666}`'
・・・

`...${...`...`...}...${...`...`...}...`
や
`...${...`...${...`...`...}...`...}...${...`...`...}...` ※旧よりはマシな結果

`...${...`...${...`...${...`...`...}...`...}...`...}...${...`...`...}...`