hanspell 0.9.6 → 0.10.0

package/{LICENSE-MIT → LICENSE}

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2018 Hyunrae Cho
+Copyright (c) 2018 Hyeonrae Jo
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,20 +1,22 @@
 # hanspell
 
-`hanspell`은 (주)다음과 부산대학교 인공지능연구실/(주)나라인포테크의 웹 서비스를 이용한 한글 맞춤법 검사기입니다.
+`hanspell`은 (주)다음과 네이버(주)의 웹 서비스를 이용한 한글 맞춤법 검사기입니다.
 
 [비주얼 스튜디오 코드 한스펠](https://github.com/9beach/vscode-hanspell)과 [하스켈](https://www.haskell.org/)로 작성한 [hanspell-hs](https://github.com/9beach/hanspell-hs)도 있으니 참고하세요.
 
-[![Build Status](https://travis-ci.org/9beach/hanspell.svg?branch=master)](https://travis-ci.org/9beach/hanspell) [![npm version](https://badge.fury.io/js/hanspell.svg)](https://badge.fury.io/js/hanspell)
+[![npm version](https://badge.fury.io/js/hanspell.svg)](https://badge.fury.io/js/hanspell)
 
 ## 설치
 
-[Node.js](https://nodejs.org/ko/)를 설치한 뒤, 다음을 실행하면 `hanspell`을 설치합니다.
+[한스펠 릴리스](https://github.com/9beach/hanspell/releases)에서 실행파일을 다운로드 하세요.
+
+소스를 받아서 설치하려면 [Node.js](https://nodejs.org/ko/) 18 이상을 설치한 뒤 다음을 실행하세요.
 
 ```sh
 npm install -g hanspell
 ```
 
-Node.js 환경에 따라 `sudo` 명령이 필요할 수도 있습니다..
+Node.js 환경에 따라 `sudo` 명령이 필요할 수도 있습니다.
 
 ```sh
 sudo npm install -g hanspell
@@ -24,11 +26,11 @@ sudo npm install -g hanspell
 
 ```console
 $ hanspell-cli -h
-사용법: hanspell-cli [-d | -p | -a | -h]
+사용법: hanspell-cli [-d | -n | -a | -h]
 
 옵션:
   -d, --daum [default]    다음 서비스를 이용해서 맞춤법을 교정합니다
-  -p, --pnu               부산대학교 서비스를 이용해서 맞춤법을 교정합니다
+  -n, --naver             네이버 서비스를 이용해서 맞춤법을 교정합니다
   -a, --all               두 서비스의 모든 결과를 반영해서 맞춤법을 교정합니다
   -h, --info              도움말을 출력합니다
 
@@ -133,7 +135,7 @@ Node.js 프로젝트에서 `hanspell` 라이브러리를 사용하려면 다음
 cd my-project && npm install --save hanspell
 ```
 
-`hanspell` 라이브러리에는 `spellCheckByDAUM` 함수와 `spellCheckByPNU` 함수가 있습니다. 다음은 사용 예입니다.
+`hanspell` 라이브러리에는 `spellCheckByDAUM` 함수와 `spellCheckByNAVER` 함수가 있습니다. 다음은 사용 예입니다.
 
 ```javascript
 // hanspell-example.js
@@ -148,10 +150,10 @@ const error = function (err) {
 };
 
 hanspell.spellCheckByDAUM(sentence, 6000, console.log, end, error);
-hanspell.spellCheckByPNU(sentence, 6000, console.log, end, error);
+hanspell.spellCheckByNAVER(sentence, 6000, console.log, end, error);
 ```
 
-다음의 결과가 예상됩니다.
+다음과 비슷한 결과가 예상됩니다.
 
 ```console
 [
@@ -167,23 +169,42 @@ hanspell.spellCheckByPNU(sentence, 6000, console.log, end, error);
   {
     token: '리랜드는',
     suggestions: [ '이랜드는' ],
-    info: '철자 검사를 해 보니 이 어절은 분석할 수 없으므로...'
+    info: '맞춤법 오류입니다.'
   },
   {
-    token: '굵은게',
-    suggestions: [ '굵은 게', '굵은데' ],
-    info: '어미의 사용이 잘못되었습니다. 문서 작성시 필요에...'
+    token: '굵은게,',
+    suggestions: [ '굵은 게,' ],
+    info: '띄어쓰기 오류입니다.'
   }
 ]
 // check ends
 ```
 
-두 함수의 호출 결과는 모두 `token`, `suggestions` 속성을 가집니다.
-`spellCheckByDAUM`은 `type`, `context` 속성을, `spellCheckByPNU`는 `info` 속성을 추가로 가집니다.
+두 함수의 호출 결과는 모두 `token`, `suggestions`, `info` 속성을 가집니다.
+`spellCheckByDAUM`은 `type`, `context` 속성을 추가로 가집니다.
+
+TypeScript 사용자는 별도 설정 없이 타입이 자동으로 인식됩니다.
+
+```typescript
+import { spellCheckByNAVER, NaverTypo } from 'hanspell';
+
+spellCheckByNAVER(
+  '안뇽하세요.',
+  6000,
+  (data: NaverTypo[]) => console.log(data),
+  () => console.log('// check ends'),
+  (err) => console.error(err),
+);
+```
+
+
+네이버 검사기는 교정 후보를 항상 하나만 제공하고, `info`는 오류 분류(맞춤법/
+띄어쓰기/표준어 추천)만 알려 줍니다.
 
-위의 예시에서 `sentence`가 300 단어 또는 1000자를 넘으면, 인자로 전달된
+위의 예시에서 `sentence`가 250 단어 또는 1000자를 넘으면, 인자로 전달된
 `console.log`는 여러 번 호출되지만 `end`는 마지막에 한 번만 호출됩니다.
 
 ## 라이선스 고지
 
-이 프로그램의 소스 코드는 MIT 라이선스를 따르지만, 부산대학교 인공지능연구실/(주)나라인포테크의 맞춤법 웹 서비스는 권리자가 고지한 대로 개인이나 학생만 무료로 사용할 수 있습니다.
+이 프로그램의 소스 코드는 MIT 라이선스를 따릅니다. 다음과 네이버의 맞춤법 웹
+서비스는 각 제공사의 이용 약관에 따라 사용해야 합니다.

package/lib/cli.js

@@ -6,7 +6,7 @@
 
 const chalk = require('chalk');
 const fs = require('fs');
-const minimatch = require('minimatch');
+const { minimatch } = require('minimatch');
 const readline = require('readline');
 
 const hanspell = require('./index');
@@ -20,6 +20,7 @@ const typomap = new Map();
 // Node v8 supports zero-length lookahead and lookbehind assertions.
 const lookaround = (() => {
   try {
+    // eslint-disable-next-line prefer-regex-literals
     RegExp('(?<=[^ㄱ-ㅎㅏ-ㅣ가-힣])test(?=[^ㄱ-ㅎㅏ-ㅣ가-힣])');
     return true;
   } catch (err) {
@@ -94,15 +95,15 @@ function checkDAUM() {
   hanspell.spellCheckByDAUM(sentence, HTTP_TIMEOUT, fixTypos, printSentence);
 }
 
-// Spell check by PNU service.
-function checkPNU() {
-  hanspell.spellCheckByPNU(sentence, HTTP_TIMEOUT, fixTypos, printSentence);
+// Spell check by NAVER service.
+function checkNAVER() {
+  hanspell.spellCheckByNAVER(sentence, HTTP_TIMEOUT, fixTypos, printSentence);
 }
 
-// Spell check by PNU service and DAUM service.
+// Spell check by both NAVER and DAUM services.
 function checkAll() {
   const input = sentence;
-  hanspell.spellCheckByPNU(input, HTTP_TIMEOUT, fixTypos, () =>
+  hanspell.spellCheckByNAVER(input, HTTP_TIMEOUT, fixTypos, () =>
     hanspell.spellCheckByDAUM(input, HTTP_TIMEOUT, fixTypos, printSentence),
   );
 }
@@ -151,11 +152,11 @@ function readAndCheck(check) {
   }
 }
 
-const HELP = `사용법: hanspell-cli [-d | -p | -a | -h]
+const HELP = `사용법: hanspell-cli [-d | -n | -a | -h]
 
 옵션:
   -d, --daum [default]    다음 서비스를 이용해서 맞춤법을 교정합니다
-  -p, --pnu               부산대학교 서비스를 이용해서 맞춤법을 교정합니다
+  -n, --naver             네이버 서비스를 이용해서 맞춤법을 교정합니다
   -a, --all               두 서비스의 모든 결과를 반영해서 맞춤법을 교정합니다
   -h, --info              도움말을 출력합니다
 
@@ -175,8 +176,8 @@ process.argv.slice(2).forEach((opt) => {
     readAndCheck(checkAll);
   } else if (opt === '-d' || opt === '--daum') {
     readAndCheck(checkDAUM);
-  } else if (opt === '-p' || opt === '--pnu') {
-    readAndCheck(checkPNU);
+  } else if (opt === '-n' || opt === '--naver') {
+    readAndCheck(checkNAVER);
   } else {
     console.log(HELP);
     process.exit(1);

package/lib/daum-spell-check.js

@@ -2,13 +2,16 @@
  * @fileOverview Interface for DAUM spell checker.
  */
 
-const Entities = require('html-entities').AllHtmlEntities;
-const request = require('request');
+const { decode } = require('html-entities');
 
 const split = require('./split-string').byLength;
 
-const entities = new Entities();
-const { decode } = entities;
+const DAUM_URL = 'https://dic.daum.net/grammar_checker.do';
+const DAUM_MAX_CHARS = 1000;
+const DAUM_MIN_INTERVAL = 400;
+const DAUM_UA =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 ' +
+  '(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
 
 // Parses attribute from server response.
 function getAttr(string, key) {
@@ -64,65 +67,69 @@ function parseJSON(response) {
   return typos;
 }
 
-const DAUM_URL = 'https://dic.daum.net/grammar_checker.do';
-const DAUM_MAX_CHARS = 1000;
-const DAUM_MIN_INTERVAL = 400;
+async function postOne(sentence, timeout) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const res = await fetch(DAUM_URL, {
+      method: 'POST',
+      headers: {
+        'User-Agent': DAUM_UA,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: new URLSearchParams({ sentence }),
+      signal: controller.signal,
+    });
+    const body = await res.text();
+    return { status: res.status, body };
+  } finally {
+    clearTimeout(timer);
+  }
+}
 
 // Splits a long sentence, and makes spell check requests to the server.
 // `check` is called at each short sentence with the parsed JSON parameter.
 function spellCheck(sentence, timeout, check, end, error) {
   if (sentence.length === 0) {
-    if (end !== null) {
-      end();
-    }
+    if (end) end();
     return;
   }
 
-  const data = split(sentence, '.,\n', DAUM_MAX_CHARS);
+  // Removes HTML tags.
+  const cleaned = sentence.replace(/<[^ㄱ-ㅎㅏ-ㅣ가-힣>]+>/g, '');
+  const data = split(cleaned, '.,\n', DAUM_MAX_CHARS);
   let count = data.length;
 
-  const getResponse = (err, response, body) => {
-    count -= 1;
-    if (!err && response.statusCode === 200) {
+  const handle = async (part) => {
+    try {
+      const { status, body } = await postOne(part, timeout);
+      if (status !== 200) throw new Error(`HTTP ${status}`);
       if (body.indexOf('="screen_out">맞춤법 검사기 본문</h2>') === -1) {
         console.error(
           `-- 한스펠 오류: 다음 서비스가 유효하지 않은 양식을 반환했습니다. (${DAUM_URL})`,
         );
-        console.log(body);
-        if (error) error(err);
+        if (error) error(new Error('invalid response'));
       } else {
         check(parseJSON(body));
       }
-    } else {
+    } catch (err) {
       console.error(
         '-- 한스펠 오류: 다음 서버의 접속 오류로 일부 문장 교정에 실패했습니다.',
       );
       if (error) error(err);
+    } finally {
+      count -= 1;
+      if (count === 0 && end) end();
     }
-    if (count === 0 && end !== null) end();
   };
 
   let i = 0;
-
-  function post() {
-    request.post(
-      {
-        url: DAUM_URL,
-        timeout,
-        form: {
-          sentence: data[i],
-        },
-      },
-      getResponse,
-    );
-
+  function next() {
+    handle(data[i]);
     i += 1;
-    if (i < data.length) {
-      setTimeout(post, DAUM_MIN_INTERVAL);
-    }
+    if (i < data.length) setTimeout(next, DAUM_MIN_INTERVAL);
   }
-
-  post();
+  next();
 }
 
 module.exports = spellCheck;

package/lib/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Type definitions for hanspell.
+ */
+
+export interface SpellCheckTypo {
+  token: string;
+  suggestions: string[];
+  info?: string;
+}
+
+export interface DaumTypo extends SpellCheckTypo {
+  type: string;
+  context: string;
+}
+
+export type NaverTypo = SpellCheckTypo;
+
+export type CheckCallback<T extends SpellCheckTypo = SpellCheckTypo> = (
+  data: T[],
+) => void;
+export type EndCallback = () => void;
+export type ErrorCallback = (err: Error | unknown) => void;
+
+export function spellCheckByDAUM(
+  sentence: string,
+  timeout: number,
+  check: CheckCallback<DaumTypo>,
+  end?: EndCallback | null,
+  error?: ErrorCallback,
+): void;
+
+export function spellCheckByNAVER(
+  sentence: string,
+  timeout: number,
+  check: CheckCallback<NaverTypo>,
+  end?: EndCallback | null,
+  error?: ErrorCallback,
+): void;

package/lib/index.js

@@ -3,6 +3,6 @@
  */
 
 const spellCheckByDAUM = require('./daum-spell-check');
-const spellCheckByPNU = require('./pnu-spell-check');
+const spellCheckByNAVER = require('./naver-spell-check');
 
-module.exports = { spellCheckByDAUM, spellCheckByPNU };
+module.exports = { spellCheckByDAUM, spellCheckByNAVER };

package/lib/naver-spell-check.js

@@ -0,0 +1,161 @@
+/**
+ * @fileOverview Interface for Naver spell checker.
+ */
+
+const { decode } = require('html-entities');
+
+const split = require('./split-string').byWordCount;
+
+const NAVER_MAX_WORDS = 250;
+const NAVER_PROXY_URL =
+  'https://m.search.naver.com/p/csearch/ocontent/util/SpellerProxy';
+const NAVER_PASSPORT_PAGE =
+  'https://search.naver.com/search.naver?query=%EB%A7%9E%EC%B6%A4%EB%B2%95+%EA%B2%80%EC%82%AC%EA%B8%B0';
+const NAVER_UA =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 ' +
+  '(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+
+const COLOR_INFO = {
+  red: '맞춤법 오류입니다.',
+  green: '띄어쓰기 오류입니다.',
+  blue: '표준어 의심이거나 대치어 추천입니다.',
+  violet: '통계적 교정입니다.',
+};
+
+let cachedPassportKey = null;
+
+async function fetchPassportKey() {
+  const res = await fetch(NAVER_PASSPORT_PAGE, {
+    headers: { 'User-Agent': NAVER_UA },
+  });
+  const body = await res.text();
+  const m = body.match(/passportKey=([a-f0-9]+)/);
+  if (!m) {
+    throw new Error('네이버 passportKey 추출 실패');
+  }
+  return m[1];
+}
+
+async function getPassportKey(forceRefresh) {
+  if (!forceRefresh && cachedPassportKey) return cachedPassportKey;
+  cachedPassportKey = await fetchPassportKey();
+  return cachedPassportKey;
+}
+
+// Strips the `jQuery(...)` JSONP wrapper.
+function unwrapJsonp(body) {
+  const start = body.indexOf('(');
+  const end = body.lastIndexOf(')');
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error('네이버 응답 파싱 실패');
+  }
+  return JSON.parse(body.substring(start + 1, end));
+}
+
+// Parses Naver response into `[{ token, suggestions, info }]`.
+function parseResult(result) {
+  if (!result || result.errata_count === 0) return [];
+
+  const origins = [];
+  const reSpan = /<span class='result_underline'>([\s\S]*?)<\/span>/g;
+  let m = reSpan.exec(result.origin_html);
+  while (m !== null) {
+    origins.push(m[1]);
+    m = reSpan.exec(result.origin_html);
+  }
+
+  const fixes = [];
+  const reEm = /<em class='([a-z]+)_text'>([\s\S]*?)<\/em>/g;
+  m = reEm.exec(result.html);
+  while (m !== null) {
+    fixes.push({ color: m[1], text: m[2] });
+    m = reEm.exec(result.html);
+  }
+
+  const len = Math.min(origins.length, fixes.length);
+  const typos = [];
+  for (let i = 0; i < len; i += 1) {
+    typos.push({
+      token: decode(origins[i]),
+      suggestions: [decode(fixes[i].text)],
+      info: COLOR_INFO[fixes[i].color] || '',
+    });
+  }
+  return typos;
+}
+
+async function callNaver(text, timeout) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  const tryOnce = async () => {
+    const key = await getPassportKey(false);
+    const url = `${NAVER_PROXY_URL}?_callback=jQuery&q=${encodeURIComponent(
+      text,
+    )}&where=nexearch&color_blindness=0&passportKey=${key}`;
+    return fetch(url, {
+      headers: {
+        'User-Agent': NAVER_UA,
+        Referer: 'https://search.naver.com/',
+      },
+      signal: controller.signal,
+    });
+  };
+
+  try {
+    let res = await tryOnce();
+    let body = await res.text();
+    if (body.includes('유효한 키가 아닙니다')) {
+      cachedPassportKey = null;
+      res = await tryOnce();
+      body = await res.text();
+    }
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return body;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// Splits a long sentence, and makes spell check requests to the server.
+// `check` is called at each short sentence with the parsed array.
+function spellCheck(sentence, timeout, check, end, error) {
+  if (sentence.length === 0) {
+    if (end) end();
+    return;
+  }
+
+  // Removes HTML tags.
+  const cleaned = sentence.replace(/<[^ㄱ-ㅎㅏ-ㅣ가-힣>]+>/g, '');
+  const parts = split(cleaned, NAVER_MAX_WORDS);
+  let count = parts.length;
+
+  const handleOne = async (part) => {
+    try {
+      const body = await callNaver(part, timeout);
+      const json = unwrapJsonp(body);
+      const result = json && json.message && json.message.result;
+      if (!result) {
+        const err = (json && json.message && json.message.error) || '응답 없음';
+        console.error(
+          `-- 한스펠 오류: 네이버 서비스가 유효하지 않은 양식을 반환했습니다. (${err})`,
+        );
+        if (error) error(new Error(err));
+      } else {
+        check(parseResult(result));
+      }
+    } catch (err) {
+      console.error(
+        '-- 한스펠 오류: 네이버 서버의 접속 오류로 일부 문장 교정에 실패했습니다.',
+      );
+      if (error) error(err);
+    } finally {
+      count -= 1;
+      if (count === 0 && end) end();
+    }
+  };
+
+  parts.forEach(handleOne);
+}
+
+module.exports = spellCheck;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hanspell",
-  "version": "0.9.6",
-  "description": "(주)다음과 부산대학교 인공지능연구실/(주)나라인포테크의 온라인 서비스를 이용한 한글 맞춤법 검사기.",
+  "version": "0.10.0",
+  "description": "(주)다음과 네이버(주)의 온라인 서비스를 이용한 한글 맞춤법 검사기.",
   "homepage": "https://github.com/9beach/hanspell",
   "author": {
     "name": "9beach",
@@ -16,6 +16,10 @@
   },
   "license": "MIT",
   "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/"
+  ],
   "scripts": {
     "all": "npm run lint && npm test",
     "test": "mocha && test/cli.test.sh",
@@ -25,6 +29,9 @@
   "bin": {
     "hanspell-cli": "lib/cli.js"
   },
+  "engines": {
+    "node": ">=18"
+  },
   "keywords": [
     "한글",
     "맞춤법",
@@ -38,20 +45,17 @@
     "SpellCheck"
   ],
   "dependencies": {
-    "chalk": "^2.4.2",
-    "html-entities": "^1.2.1",
-    "minimatch": "^3.0.4",
-    "readline": "^1.3.0",
-    "request": "^2.65.0",
-    "unescape": "^1.0.1"
+    "chalk": "^4.1.2",
+    "html-entities": "^2.6.0",
+    "minimatch": "^10.2.5"
   },
   "devDependencies": {
-    "eslint": "^7.19.0",
-    "eslint-config-airbnb-base": "^14.2.1",
-    "eslint-config-prettier": "^7.2.0",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-prettier": "^3.3.1",
-    "mocha": "^9.1.2",
-    "prettier": "^2.2.1"
+    "eslint": "^8.57.1",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "mocha": "^11.7.6",
+    "prettier": "^3.8.3"
   }
 }

package/.eslintrc.yml

@@ -1,15 +0,0 @@
-env:
-  browser: true
-  commonjs: true
-  es2021: true
-  mocha: true
-extends:
-  - eslint:recommended
-  - airbnb-base
-  - plugin:prettier/recommended
-parserOptions:
-  ecmaVersion: 12
-rules:
-  max-len: ["error", {"code": 80, "ignoreUrls": true}]
-  prettier/prettier: "error"
-  no-console: "off"

package/.prettierrc

@@ -1,6 +0,0 @@
-singleQuote: true
-semi: true
-useTabs: false
-tabWidth: 2
-trailingComma: "all"
-printWidth: 80

package/.travis.yml

@@ -1,6 +0,0 @@
-language: node_js
-node_js:
-  - 15
-  - 10
-before_script:
-  - npm run lint

package/lib/pnu-spell-check.js

@@ -1,106 +0,0 @@
-/**
- * @fileOverview Interface for Pusan National University spell checker.
- */
-
-const request = require('request');
-const Entities = require('html-entities').AllHtmlEntities;
-
-const split = require('./split-string').byWordCount;
-
-const entities = new Entities();
-const { decode } = entities;
-
-// Parses server response.
-function parseJSON(response) {
-  try {
-    return response
-      .match(/\tdata = \[.*;/g)
-      .map((data) => JSON.parse(data.substring(8, data.length - 1)))[0][0]
-      .errInfo.map((pnutypo) => {
-        let suggestions = pnutypo.candWord.replace(/\|$/, '');
-        if (suggestions === '') {
-          suggestions = decode(pnutypo.orgStr);
-        }
-        const info = pnutypo.help
-          .replace(/< *[bB][rR] *\/>/g, '\n')
-          .replace(/\n\n/g, '\n')
-          .replace(/\n\(예\) /g, '\n(예)\n')
-          .replace(/  \(예\) /g, '\n(예)\n')
-          .replace(/   */g, '\n');
-
-        return {
-          token: decode(pnutypo.orgStr),
-          suggestions: decode(suggestions).split('|'),
-          info: decode(info),
-        };
-      });
-  } catch (err) {
-    if (
-      response.indexOf(
-        '기술적 한계로 찾지 못한 맞춤법 오류나 문법  오류가 있을 수 있습니다.',
-      ) !== -1
-    ) {
-      console.error(
-        '-- 한스펠 오류: 부산대 서비스가 유효하지 않은 양식을 반환했습니다.',
-      );
-    }
-  }
-
-  return [];
-}
-
-const PNU_MAX_WORDS = 250;
-const PNU_URL = 'http://speller.cs.pusan.ac.kr/results';
-
-// Splits a long sentence, and makes spell check requests to the server.
-// `check` is called at each short sentence with the parsed JSON parameter.
-function spellCheck(sentence, timeout, check, end, error) {
-  if (sentence.length === 0) {
-    if (end !== null) {
-      end();
-    }
-    return;
-  }
-
-  // Due to PNU server's weird behavior, replaces '\n' to '\n '.
-  const data = split(
-    `${sentence.replace(/([^\r])\n/g, '$1\r\n')}\r\n`,
-    PNU_MAX_WORDS,
-  );
-  let count = data.length;
-
-  const getResponse = (err, response, body) => {
-    if (!err && response.statusCode === 200) {
-      if (body.indexOf('<title>한국어 맞춤법/문법 검사기</title>') === -1) {
-        console.error(
-          `-- 한스펠 오류: 부산대 서비스가 유효하지 않은 양식을 반환했습니다. (${PNU_URL})`,
-        );
-        if (error) error(err);
-      } else {
-        check(parseJSON(body));
-      }
-    } else {
-      console.error(
-        '-- 한스펠 오류: 부산대 서버의 접속 오류로 일부 문장 교정에 실패했습니다.',
-      );
-      if (error) error(err);
-    }
-    count -= 1;
-    if (count === 0 && end !== null) end();
-  };
-
-  data.forEach((part) =>
-    request.post(
-      {
-        url: PNU_URL,
-        timeout,
-        form: {
-          text1: part,
-        },
-      },
-      getResponse,
-    ),
-  );
-}
-
-module.exports = spellCheck;