@retorquere/bibtex-parser 12.1.2 → 12.1.4

package/dist/wasm/index.js

@@ -1,122 +1,99 @@
-import init, {
-  initSync,
-  parseNormalized as parseNormalizedWasm,
-  parseVerbatim as parseVerbatimWasm,
-  tokenize as tokenizeWasm,
-  toSentenceCase as toSentenceCaseWasm,
-} from './bibtex_parser.js'
-
-export { init, initSync }
-export default init
-
-const english = [
-  '', 'american', 'british', 'canadian', 'english', 'australian', 'newzealand',
-  'usenglish', 'ukenglish', 'en', 'eng', 'en-au', 'en-bz', 'en-ca', 'en-cb',
-  'en-gb', 'en-ie', 'en-jm', 'en-nz', 'en-ph', 'en-tt', 'en-us', 'en-za', 'en-zw', 'anglais',
-]
-
-function rustOptions(options = {}) {
-  const rust = Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined))
-
-  if (rust.unsupported !== undefined && typeof rust.unsupported !== 'string') {
-    throw new TypeError('unsupported must be ignore, keep, or throw')
-  }
-  if (rust.unsupported !== undefined && !['ignore', 'keep', 'throw'].includes(rust.unsupported)) {
-    throw new TypeError('unsupported must be ignore, keep, or throw')
-  }
-
-  if (typeof rust.strings === 'string') {
-    rust.stringsSource = rust.strings
-    delete rust.strings
-  }
-  else if (!rust.strings) {
-    delete rust.strings
-  }
-  if (typeof rust.english === 'boolean') {
-    rust.english = rust.english ? english : []
-  }
-  else if (Array.isArray(rust.english)) {
-    const configured = rust.english
-    rust.english = [...english]
-    configured.forEach((language, index) => {
-      rust.english[index] = language
-    })
-  }
-  if (rust.sentenceCase === false) {
-    rust.english = []
-    rust.sentenceCase = { guess: false, subSentence: false, preserveQuoted: false }
-  }
-  if (rust.caseProtection === false) rust.caseProtection = 'off'
-  if (rust.caseProtection === true) rust.caseProtection = 'as-needed'
-  if (Array.isArray(rust.verbatimFields)) {
-    rust.verbatimFields = rust.verbatimFields.filter(field => typeof field === 'string')
-  }
-  if (rust.unsupported === 'ignore') rust.ignoreUnsupported = true
-  delete rust.unsupported
-  return rust
-}
-
-function library(result) {
-  if (Array.isArray(result.preambles)) {
-    result.preamble = result.preambles
-    delete result.preambles
-  }
-  return result
+/** @module wasm */
+import init, { initSync, parse as parseWasm, parseAsync as parseAsyncWasm, parseVerbatim as parseVerbatimWasm, parseVerbatimAsync as parseVerbatimAsyncWasm, tokenize as tokenizeWasm, toSentenceCase as toSentenceCaseWasm } from './bibtex_parser.js';
+/** Initializes the WebAssembly parser; await this before using its exports. */
+export { init, initSync };
+export default init;
+/** Default language identifiers treated as English. */
+export const english = [
+    '',
+    'american',
+    'british',
+    'canadian',
+    'english',
+    'australian',
+    'newzealand',
+    'usenglish',
+    'ukenglish',
+    'en',
+    'eng',
+    'en-au',
+    'en-bz',
+    'en-ca',
+    'en-cb',
+    'en-gb',
+    'en-ie',
+    'en-jm',
+    'en-nz',
+    'en-ph',
+    'en-tt',
+    'en-us',
+    'en-za',
+    'en-zw',
+    'anglais',
+];
+function prepare(input, options = {}) {
+    const parserOptions = Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
+    if (typeof parserOptions.strings === 'string') {
+        input = `${parserOptions.strings}\n${input}`;
+        delete parserOptions.strings;
+    }
+    if (parserOptions.unsupported && !['ignore', 'keep', 'throw'].includes(parserOptions.unsupported)) {
+        throw new TypeError('unsupported must be ignore, keep, or throw');
+    }
+    if (parserOptions.unsupported === 'ignore')
+        parserOptions.ignoreUnsupported = true;
+    delete parserOptions.unsupported;
+    if (Array.isArray(parserOptions.verbatimFields)) {
+        parserOptions.verbatimFields = parserOptions.verbatimFields.map((field) => {
+            if (typeof field === 'string')
+                return field;
+            const flags = `${field.multiline ? 'm' : ''}${field.dotAll ? 's' : ''}`;
+            const source = flags ? `(?${flags}:${field.source})` : field.source;
+            return { source: field.sticky ? `\\A(?:${source})` : source };
+        });
+    }
+    return { input, options: parserOptions };
 }
-
 function throwOnUnsupported(result) {
-  const unsupported = result.errors.find(error => error.error.startsWith('unhandled macro ') || error.error.startsWith('unhandled environment '))
-  if (unsupported) throw new Error(unsupported.error)
-  return result
+    const unsupported = result.errors.find(error => error.error.startsWith('unhandled macro ') || error.error.startsWith('unhandled environment '));
+    if (unsupported)
+        throw new Error(unsupported.error);
+    return result;
 }
-
+/** Parses BibTeX while leaving field contents uninterpreted. */
 export function parseVerbatim(input, options = {}) {
-  const result = parseVerbatimWasm(input, rustOptions(options))
-  delete result.jabref
-  return result
+    const prepared = prepare(input, options);
+    return parseVerbatimWasm(prepared.input, prepared.options);
 }
-
-export function parseNormalized(input, options = {}) {
-  const selectors = options.verbatimFields || []
-  const patterns = selectors.filter(selector => selector instanceof RegExp)
-  let normalizedOptions = options
-  if (patterns.length) {
-    const exactFields = new Set(selectors.filter(selector => typeof selector === 'string'))
-    const raw = parseVerbatimWasm(input, rustOptions({
-      ...options,
-      verbatimFields: [...exactFields],
-    }))
-    for (const entry of raw.entries) {
-      for (const field of Object.keys(entry.fields)) {
-        if (patterns.some(pattern => field.match(new RegExp(
-          pattern.source,
-          pattern.flags.includes('i') ? pattern.flags : `${pattern.flags}i`,
-        )))) {
-          exactFields.add(field)
-        }
-      }
-    }
-    normalizedOptions = { ...options, verbatimFields: [...exactFields] }
-  }
-  const result = library(parseNormalizedWasm(input, rustOptions(normalizedOptions)))
-  if (options.unsupported === 'throw') return throwOnUnsupported(result)
-  return result
+/** Asynchronous variant of {@link parseVerbatim}. */
+export async function parseVerbatimAsync(input, options = {}) {
+    const prepared = prepare(input, options);
+    return await parseVerbatimAsyncWasm(prepared.input, prepared.options);
 }
-
+/** Parses BibTeX or BibLaTeX source into a normalized library. */
 export function parse(input, options = {}) {
-  return parseNormalized(input, options)
+    const prepared = prepare(input, options);
+    const result = parseWasm(prepared.input, prepared.options);
+    if (options.unsupported === 'throw')
+        return throwOnUnsupported(result);
+    return result;
 }
-
+/** Asynchronous variant of {@link parse}, yielding during large parses. */
 export async function parseAsync(input, options = {}) {
-  return parseNormalized(input, options)
+    const prepared = prepare(input, options);
+    const result = await parseAsyncWasm(prepared.input, prepared.options);
+    if (options.unsupported === 'throw')
+        return throwOnUnsupported(result);
+    return result;
 }
-
+/** Converts a title to sentence case using heuristic token classification. */
 export function toSentenceCase(input, options = {}) {
-  return toSentenceCaseWasm(input, options)
+    return toSentenceCaseWasm(input, options);
 }
-
+/** Splits text into classified tokens with source offsets. */
 export function tokenize(input, markup) {
-  if (!(markup instanceof RegExp)) return tokenizeWasm(input)
-  const masked = input.replace(markup, match => '\u2060'.repeat(match.length))
-  return tokenizeWasm(masked)
-}
+    if (!(markup instanceof RegExp))
+        return tokenizeWasm(input);
+    const masked = input.replace(markup, match => '\u2060'.repeat(match.length));
+    return tokenizeWasm(masked);
+}

package/dist/wasm/snippets/rq-bibtex-parser-a708c588fcf0dba5/inline0.js

@@ -0,0 +1 @@
+export function playnice() { return new Promise(resolve => setTimeout(resolve, 0)); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retorquere/bibtex-parser",
-  "version": "12.1.2",
+  "version": "12.1.4",
   "description": "BibTeX parser",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -47,7 +47,7 @@
     "postversion": "git push --follow-tags",
     "update-cases": "curl -s https://raw.githubusercontent.com/retorquere/zotero-better-bibtex/master/test/loaded.json | jq -r '.[] | select(test(\"\\\\.bib((la)?tex)?$\"))' | rsync -av --delete -m --files-from=- ../better-bibtex/test/fixtures/ test/better-bibtex/",
     "predocs": "npm start",
-    "docs": "typedoc --tsconfig tsconfig.cjs.json",
+    "docs": "typedoc --tsconfig tsconfig.typedoc.json",
     "modules": "git submodule update --init --recursive",
     "wasm:test": "npm run build:wasm && node --test test/wasm.js test/rust-wasm-parity.test.js",
     "ncu": "./build/submodules.py && ./build/crossref.py && ncu -u && npm i && git add package.json package-lock.json && npm audit fix && git commit -m ncu"
@@ -62,22 +62,22 @@
   "author": "Emiliano Heyns",
   "license": "ISC",
   "devDependencies": {
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.6.5",
     "@unified-latex/unified-latex-types": "^1.8.4",
     "command-line-args": "^6.0.2",
-    "csv": "^6.6.3",
+    "csv": "^6.6.4",
     "digital-tree": "^2.0.4",
-    "dprint": "^0.55.2",
-    "ejs": "^6.0.1",
+    "dprint": "^0.63.0",
+    "ejs": "^7.0.1",
     "esbuild": "^0.28.2",
     "glob": "^13.0.6",
-    "js-yaml": "^5.2.3",
+    "js-yaml": "^5.4.3",
     "minimist": "^1.2.8",
     "mkdirp": "^3.0.1",
     "node-fetch": "^3.3.2",
-    "piscina": "^5.3.0",
+    "piscina": "^5.3.2",
     "slug": "^12.0.1",
-    "tap": "^21.7.5",
+    "tap": "^21.8.0",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
     "typedoc": "^0.28.20",
@@ -92,7 +92,7 @@
     "lodash.merge": "^4.6.2",
     "moo": "^0.5.3",
     "nearley": "^2.20.1",
-    "unicode2latex": "^7.0.33",
+    "unicode2latex": "^7.0.37",
     "wink-eng-lite-web-model": "^1.8.1",
     "wink-nlp": "^2.4.0"
   },
@@ -103,5 +103,9 @@
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "allowScripts": {
+    "esbuild@0.28.2": true,
+    "dprint@0.63.0": true
   }
 }