@ai0x1337/budoux-extension 0.0.1-security → 99.0.0

package/budoux-extension-backup/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "budoux-extension",
+  "version": "1.0.0",
+  "description": "",
+  "engines": {
+    "node": ">=16.0"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "npm run bundle",
+    "rebuild": "npm run clean && npm run build",
+    "tsc:cjs": "tsc",
+    "tsc:es": "tsc --module ES2020",
+    "prebundle": "npm run tsc:es",
+    "bundle": "node scripts/esbuild.js",
+    "predist": "npm run bundle",
+    "dist": "ts-node scripts/package.ts -d dist --js build/bundle",
+    "prezip": "npm run clean && npm run dist",
+    "zip": "ts-node scripts/package.ts -d dist --zip budoux.zip",
+    "bundle:test": "esbuild build/tests/index.browser.js --outdir=build/bundle --bundle --sourcemap",
+    "pretest": "npm run tsc:es && npm run bundle:test",
+    "test": "karma start --single-run",
+    "lint": "eslint src/** tests/** --no-error-on-unmatched-pattern",
+    "fix": "eslint src/** tests/** --no-error-on-unmatched-pattern --fix",
+    "clean": "node scripts/clean.js && gts clean"
+  },
+  "author": "Koji Ishii",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@material/mwc-button": "^0.27.0",
+    "@material/mwc-formfield": "^0.27.0",
+    "@material/mwc-radio": "^0.27.0",
+    "@material/mwc-textfield": "^0.27.0",
+    "budoux": "^0.7.0",
+    "budoux-extension": "file:"
+  },
+  "devDependencies": {
+    "@types/archiver": "^6.0.0",
+    "@types/chrome": "^0.1.0",
+    "@types/jasmine": "^5.1.0",
+    "@types/jsdom": "^21.1.1",
+    "@types/node": "^24.0.1",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "archiver": "^7.0.1",
+    "commander": "^14.0.0",
+    "esbuild": "^0.25.0",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^10.0.2",
+    "eslint-plugin-prettier": "^5.2.1",
+    "glob": "^11.0.0",
+    "jasmine": "^5.1.0",
+    "jsdom": "^26.0.0",
+    "karma": "^6.4.2",
+    "karma-chrome-launcher": "^3.2.0",
+    "karma-jasmine": "^5.1.0",
+    "ts-node": "^10.4.0",
+    "typescript": "^5.1.3"
+  }
+}

package/budoux-extension-backup/scripts/clean.js

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const fs = require('fs');
+const {glob} = require('glob');
+
+const dirs = ['build', 'dist'];
+const patterns = ['*.crx', '*.zip', '**/Icon[\r]*', '**/desktop.ini'];
+
+function logRemoving(file) {
+  console.log(`Removing ${file} ...`);
+}
+
+function isDirectoryExists(dir) {
+  try {
+    return fs.statSync(dir).isDirectory();
+  } catch (error) {
+    if (error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+for (const dir of dirs) {
+  if (isDirectoryExists(dir)) {
+    logRemoving(dir);
+    (fs.rmSync || fs.rmdirSync)(dir, {recursive: true});
+  }
+}
+
+for (const pattern of patterns) {
+  glob(pattern, (err, files) => {
+    if (err) throw err;
+    for (const file of files) {
+      logRemoving(file);
+      fs.unlinkSync(file);
+    }
+  });
+}

package/budoux-extension-backup/scripts/esbuild.js

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+require('esbuild').build({
+  entryPoints: [
+    'build/src/background.js',
+    'build/src/content.js',
+    'build/src/options.js',
+  ],
+  bundle: true,
+  minify: true,
+  outdir: 'build/bundle',
+  sourcemap: true,
+});

package/budoux-extension-backup/scripts/package.ts

@@ -0,0 +1,98 @@
+/* eslint-disable prettier/prettier */
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as archiver from 'archiver';
+import {Command} from 'commander';
+import * as fs from 'fs';
+const {glob} = require('glob');
+import * as path from 'path';
+
+const log = console.log;
+
+function throwMissingArg(name: string): never {
+  throw new Error(`Missing ${name}`);
+}
+
+class ChromeExtensionPackage {
+  async run() {
+    const program = new Command();
+    program.option('-d, --dir <dir>', 'unpacked extension directory');
+    program.option('-j --js <dir>', 'JavaScript directory');
+    program.option('-z, --zip <zip>', 'ZIP file name');
+    program.parse(process.argv);
+    const options = program.opts();
+    const dist_dir = options.dir ?? throwMissingArg('extension directory');
+    const js_dir = options.js;
+    if (js_dir) {
+      await this.copy(js_dir, dist_dir);
+    }
+    const zip_path = options.zip;
+    if (zip_path) {
+      await this.zip(dist_dir, zip_path);
+    }
+  }
+
+  async copy(js_dir: string, dist_dir: string) {
+    if (!fs.existsSync(dist_dir)) {
+      await fs.promises.mkdir(dist_dir, {recursive: true});
+    }
+    // Bundles are copied from `js_dir` to the root of `dist_dir`.
+    const bundles = ['background.js', 'content.js', 'options.js']
+      .map(name => [path.join(js_dir, name), name]);
+    // Resources are copied to the root of `dist_dir`.
+    const resources = [
+      'manifest.json',
+      'src/options.html',
+      'docs/icon128.png',
+    ].map(name => [name, path.basename(name)]);
+    // Locales are copied to the `dist_dir` keeping the tree structure.
+    const locales: string[][] = (await glob('_locales/**/*.json'))
+      .map((name: string) => [name, name]);
+    const files = [...bundles, ...resources, ...locales]
+      .map(([src, dest]) => [src, path.join(dist_dir, dest)]);
+    for (const [, dest] of files) {
+      const dir = path.dirname(dest);
+      if (!fs.existsSync(dir)) await fs.promises.mkdir(dir, {recursive: true});
+    }
+    await Promise.all(
+      files.map(([src, dest]) => {
+        log(`Copying ${src} -> ${dest}`);
+        return fs.promises.copyFile(src, dest);
+      })
+    );
+  }
+
+  async zip(src_dir: string, zip_path: string) {
+    if (!fs.existsSync(src_dir)) {
+      throw new Error(`Directory not found: ${src_dir}`);
+    }
+    const output = fs.createWriteStream(zip_path);
+    const closed_or_ended = new Promise<void>(resolve => {
+      output.on('close', resolve);
+      output.on('end', resolve);
+    });
+    const archive = archiver('zip', {
+      zlib: {level: 9},
+    });
+    archive.pipe(output);
+    archive.directory(src_dir, false);
+    await Promise.all([archive.finalize(), closed_or_ended]);
+    log(`${zip_path}: ${archive.pointer()} bytes`);
+  }
+}
+
+new ChromeExtensionPackage().run();

package/budoux-extension-backup/src/background.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const assert = console.assert;
+
+async function applyBudouX(tab?: chrome.tabs.Tab, frameId?: number) {
+  const tabId = tab?.id;
+  assert(tabId !== undefined, tab);
+  if (tabId === undefined) return;
+  const target: chrome.scripting.InjectionTarget = {
+    tabId: tabId,
+    frameIds: frameId !== undefined ? [frameId] : undefined,
+  };
+  await chrome.scripting.executeScript({
+    target: target,
+    files: ['content.js'],
+  });
+
+  await chrome.action.setBadgeText({
+    text: 'ON',
+    tabId: tabId,
+  });
+  await chrome.action.setBadgeBackgroundColor({
+    color: '#00c853',
+    tabId: tabId,
+  });
+}
+
+chrome.runtime.onInstalled.addListener(() => {
+  chrome.contextMenus.create({
+    id: 'BudouX',
+    title: chrome.i18n.getMessage('applyMenuTitle'),
+    contexts: ['all'],
+  });
+});
+
+chrome.contextMenus.onClicked.addListener(async (info, tab) => {
+  await applyBudouX(tab, info.frameId);
+});
+chrome.action.onClicked.addListener(applyBudouX);

package/budoux-extension-backup/src/content.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {DocumentApplier} from './document_applier';
+
+DocumentApplier.fromDocument(document).apply();

package/budoux-extension-backup/src/document_applier.ts

@@ -0,0 +1,148 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  loadDefaultJapaneseParser,
+  loadDefaultParsers,
+  HTMLProcessor,
+  Parser,
+} from 'budoux';
+
+const isDebug = false;
+
+// eslint-disable-next-line  @typescript-eslint/no-explicit-any
+function logDebug(...args: any[]) {
+  if (isDebug) {
+    console.log(...args);
+  }
+}
+
+export class DocumentApplier {
+  private document: Document;
+  protected separator = '\u200B';
+  private className = 'BudouX';
+  private isClassDefined = false;
+
+  constructor(document: Document) {
+    this.document = document;
+  }
+
+  static fromDocument(document: Document): DocumentApplier {
+    // @ts-expect-error Use a dynamic property of the document.
+    let docApplier = document.budouX;
+    logDebug('fromDocument: ', docApplier);
+    if (!docApplier) {
+      docApplier = new DocumentApplier(document);
+      // @ts-expect-error Use a dynamic property of the document.
+      document.budouX = docApplier;
+    }
+    return docApplier;
+  }
+
+  async apply() {
+    await this.loadSettings();
+    const parser = this.loadParser();
+    const applier = new HTMLProcessor(parser, {
+      className: this.className,
+      separator: this.separator,
+    });
+
+    const document = this.document;
+    await this.waitForDOMContentLoaded(document);
+
+    this.ensureClass();
+    applier.applyToElement(document.body);
+  }
+
+  private loadParser(): Parser {
+    const document = this.document;
+    const element = document.body ?? document.documentElement;
+    let lang = DocumentApplier.langFromElement(element);
+    lang = DocumentApplier.normalizeLocale(lang);
+    if (lang) {
+      const parsers = loadDefaultParsers();
+      const parser = parsers.get(lang);
+      if (parser) return parser;
+    }
+    console.warn(`No parser for "${lang}", using the Japanese parser.`);
+    return loadDefaultJapaneseParser();
+  }
+
+  protected async loadSettings() {
+    if ('chrome' in window && 'storage' in chrome) {
+      await new Promise<void>(resolve => {
+        chrome.storage.sync.get(
+          {
+            separator: this.separator,
+          },
+          items => {
+            this.separator = items.separator;
+            resolve();
+          }
+        );
+      });
+    }
+  }
+
+  private ensureClass(): void {
+    if (this.isClassDefined || !this.className) return;
+    this.isClassDefined = true;
+
+    const document = this.document;
+    const styleElement = document.createElement('style');
+    styleElement.textContent = `.${this.className} { word-break: keep-all; overflow-wrap: anywhere; }`;
+    document.head.appendChild(styleElement);
+  }
+
+  static normalizeLocale(locale?: string): string | undefined {
+    if (!locale) return undefined;
+    let subtags = locale.split('-');
+    if (!subtags.length) return undefined;
+    // The first subtag is the language.
+    const lang = subtags[0].toLowerCase();
+    if (lang === 'zh') {
+      // `zh` requires the script subtag.
+      subtags = subtags.slice(1);
+      for (const subtag of subtags) {
+        if (subtag.match(/^han[st]$/i))
+          return `${lang}-${subtag.toLowerCase()}`;
+      }
+      // If neither `hans` nor `hant`, check the region or the macrolanguage.
+      for (const subtag of subtags) {
+        if (subtag.match(/^(hk|mo|tw|hak|lzh|nan|yue)$/i)) return 'zh-hant';
+      }
+      return 'zh-hans';
+    }
+    return lang;
+  }
+
+  static langFromElement(element: HTMLElement | null): string | undefined {
+    for (; element; element = element.parentElement) {
+      const lang = element.lang;
+      if (lang) return lang;
+    }
+    return undefined;
+  }
+
+  async waitForDOMContentLoaded(document: Document) {
+    logDebug('waitForDOMContentLoaded: ', document.readyState);
+    if (document.readyState !== 'loading') return;
+    await new Promise<void>(resolve => {
+      document.addEventListener('DOMContentLoaded', () => resolve());
+    });
+    logDebug('DOMContentLoaded: ', document.readyState);
+  }
+}

package/budoux-extension-backup/src/options.html

@@ -0,0 +1,109 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf-8">
+  <link
+    href="https://fonts.googleapis.com/css?family=Google+Sans:400,500,700&amp;display=swap&amp;lang=en"
+    rel="stylesheet">
+  <style>
+    :root {
+      --mdc-theme-primary: #9c27b0;
+      --mdc-theme-secondary: #64dd17;
+      height: 100%;
+      user-select: none;
+    }
+
+    body {
+      align-items: center;
+      background: #ede7f6;
+      display: flex;
+      font-family: 'Google Sans', sans-serif;
+      height: 100%;
+      justify-content: center;
+      margin: 0;
+      padding: 0 1rem;
+    }
+
+    section {
+      background: #fff;
+      border-radius: 0.5rem;
+      box-shadow: 0 2px 4px rgba(0, 0, 0, .2);
+      box-sizing: border-box;
+      max-width: 460px;
+      padding: 2rem;
+      width: 100%;
+    }
+
+    h1 {
+      font-family: 'Google Sans', sans-serif;
+      font-size: 1.5rem;
+      font-weight: 500;
+      line-height: 3rem;
+      margin: 0;
+    }
+
+    p {
+      align-items: center;
+      display: flex;
+      line-height: 1.5rem;
+      margin: 1rem 0;
+    }
+
+    .button-container {
+      margin-top: 2rem;
+    }
+
+    mwc-formfield {
+      /* Prevent wrapping of label text on e.g., Windows */
+      word-break: keep-all;
+    }
+
+    mwc-textfield {
+      margin-left: 1rem;
+    }
+
+    .powered-by {
+      align-self: flex-end;
+      margin-left: auto;
+    }
+  </style>
+
+</head>
+
+<body>
+  <section>
+    <h1>BudouX Chrome Extension 🍇</h1>
+    <p>
+      <mwc-formfield label="__MSG_insertZwSpace__">
+        <mwc-radio id="zwsp" name="separator" value="&#x200B;"></mwc-radio>
+      </mwc-formfield>
+    </p>
+    <p>
+      <mwc-formfield label="__MSG_insertSpace__">
+        <mwc-radio id="space" name="separator" value=" "></mwc-radio>
+      </mwc-formfield>
+    </p>
+    <p>
+      <mwc-formfield label="__MSG_insertIdeoSpace__">
+        <mwc-radio id="idsp" name="separator" value="&#x3000;"></mwc-radio>
+      </mwc-formfield>
+    </p>
+    <p>
+      <mwc-formfield label="__MSG_insertUserText__">
+        <mwc-radio id="other" name="separator" value="other"></mwc-radio>
+      </mwc-formfield>
+      <mwc-textfield id="separatorText" outlined></mwc-textfield>
+    </p>
+    <p class="button-container">
+      <mwc-button raised id="save" type="submit" label="__MSG_save__"></mwc-button>
+      <span class="powered-by">
+        Powered by
+        <a href="https://github.com/google/budoux" target="_blank">BudouX</a>
+      </span>
+    </p>
+  </section>
+  <script src="options.js"></script>
+</body>
+
+</html>

package/budoux-extension-backup/src/options.ts

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import '@material/mwc-radio';
+import '@material/mwc-button';
+import '@material/mwc-formfield';
+import '@material/mwc-textfield';
+import {Radio} from '@material/mwc-radio';
+import {TextField} from '@material/mwc-textfield';
+import {Button} from '@material/mwc-button';
+
+const zwsp = document.getElementById('zwsp') as Radio;
+const idsp = document.getElementById('idsp') as Radio;
+const space = document.getElementById('space') as Radio;
+const presets = [zwsp, idsp, space];
+const other = document.getElementById('other') as Radio;
+const separatorText = document.getElementById('separatorText') as TextField;
+const saveButton = document.getElementById('save') as Button;
+
+function checkOtherIfNeeded() {
+  if (separatorText.value) other.checked = true;
+}
+
+function getSeparator() {
+  for (const preset of presets) {
+    if (preset.checked) return preset.value;
+  }
+  return separatorText.value;
+}
+
+function setSeparator(separator: string) {
+  for (const preset of presets) {
+    if (separator === preset.value) {
+      preset.checked = true;
+      return;
+    }
+  }
+  other.checked = true;
+  separatorText.value = separator;
+}
+
+function saveOptions() {
+  chrome.storage.sync.set({
+    separator: getSeparator(),
+  });
+}
+
+function restoreOptions() {
+  chrome.storage.sync.get(
+    {
+      separator: '\u200B',
+    },
+    items => {
+      setSeparator(items.separator);
+    }
+  );
+}
+
+function localizeString(str: string): string {
+  return str.replace(/__MSG_(\w+)__/g, (match, name) =>
+    name ? chrome.i18n.getMessage(name) : ''
+  );
+}
+
+function localize() {
+  for (const element of document.querySelectorAll(
+    'mwc-button, mwc-formfield'
+  )) {
+    const label = element.getAttribute('label');
+    if (label) {
+      element.setAttribute('label', localizeString(label));
+    }
+  }
+}
+
+localize();
+document.addEventListener('DOMContentLoaded', restoreOptions);
+saveButton.addEventListener('click', saveOptions);
+separatorText.addEventListener('input', checkOtherIfNeeded);

package/budoux-extension-backup/tests/index.browser.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import './test_document_applier.js';