@stackline/wcwidth 1.0.0

package/lib/width.js

@@ -0,0 +1,91 @@
+'use strict'
+
+const {
+  EMOJI,
+  EMOJI_PRESENTATION,
+  EXTENDED_PICTOGRAPHIC,
+  UNICODE_VERSION,
+  WIDE,
+  ZERO_WIDTH
+} = require('./unicode-tables')
+const { splitGraphemeCodePoints } = require('./graphemes')
+const { inRanges } = require('./ranges')
+
+const TEXT_VARIATION_SELECTOR = 0xfe0e
+const EMOJI_VARIATION_SELECTOR = 0xfe0f
+const ZERO_WIDTH_JOINER = 0x200d
+const COMBINING_ENCLOSING_KEYCAP = 0x20e3
+
+function measure(value, options) {
+  if (typeof value !== 'string') return codePointWidth(value, options)
+
+  const asciiWidth = printableAsciiWidth(value)
+  if (asciiWidth !== -1) return asciiWidth
+
+  let total = 0
+  for (const cluster of splitGraphemeCodePoints(value)) {
+    const width = graphemeWidth(cluster, options)
+    if (width < 0) return -1
+    total += width
+  }
+  return total
+}
+
+function printableAsciiWidth(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index)
+    if (codeUnit < 0x20 || codeUnit > 0x7e) return -1
+  }
+  return value.length
+}
+
+function graphemeWidth(points, options) {
+  if (isEmojiCluster(points)) return 2
+
+  let total = 0
+  for (const point of points) {
+    const width = codePointWidth(point, options)
+    if (width < 0) return -1
+    total += width
+  }
+  return total
+}
+
+function codePointWidth(point, options) {
+  if (point === 0) return options.nul
+  if (point < 32 || (point >= 0x7f && point < 0xa0)) return options.control
+  if (inRanges(point, ZERO_WIDTH)) return 0
+  if (inRanges(point, WIDE)) return 2
+  return 1
+}
+
+function isEmojiCluster(points) {
+  if (points.includes(TEXT_VARIATION_SELECTOR) && !points.includes(EMOJI_VARIATION_SELECTOR)) {
+    return false
+  }
+
+  const hasEmoji = points.some((point) => inRanges(point, EMOJI))
+  if (hasEmoji && points.includes(EMOJI_VARIATION_SELECTOR)) return true
+  if (points.includes(COMBINING_ENCLOSING_KEYCAP) && points.some(isKeycapBase)) return true
+  if (points.some((point) => inRanges(point, EMOJI_PRESENTATION))) return true
+
+  if (points.includes(ZERO_WIDTH_JOINER)) {
+    let pictographs = 0
+    for (const point of points) {
+      if (inRanges(point, EXTENDED_PICTOGRAPHIC)) pictographs += 1
+    }
+    if (pictographs >= 2) return true
+  }
+
+  return false
+}
+
+function isKeycapBase(point) {
+  return point === 0x23 || point === 0x2a || (point >= 0x30 && point <= 0x39)
+}
+
+module.exports = {
+  UNICODE_VERSION,
+  codePointWidth,
+  measure
+}

package/package.json

@@ -0,0 +1,149 @@
+{
+  "name": "@stackline/wcwidth",
+  "version": "1.0.0",
+  "description": "Terminal column widths with modern Unicode grapheme support and wcwidth compatibility",
+  "keywords": [
+    "terminal",
+    "unicode",
+    "width",
+    "wcwidth",
+    "grapheme",
+    "emoji"
+  ],
+  "license": "MIT",
+  "type": "commonjs",
+  "sideEffects": false,
+  "main": "./index.js",
+  "module": "./dist/index.mjs",
+  "types": "./index.d.ts",
+  "typings": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./index.d.mts",
+        "require": "./index.d.cts",
+        "default": "./index.d.ts"
+      },
+      "browser": {
+        "import": "./dist/index.mjs",
+        "require": "./index.js",
+        "default": "./index.js"
+      },
+      "import": "./dist/index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
+    },
+    "./index.js": {
+      "types": {
+        "import": "./index.d.mts",
+        "require": "./index.d.cts",
+        "default": "./index.d.ts"
+      },
+      "import": "./dist/index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
+    },
+    "./combining": {
+      "types": "./combining.d.ts",
+      "require": "./combining.js",
+      "default": "./combining.js"
+    },
+    "./combining.js": {
+      "types": "./combining.d.ts",
+      "require": "./combining.js",
+      "default": "./combining.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "index.mjs",
+    "index.d.ts",
+    "index.d.cts",
+    "index.d.mts",
+    "combining.js",
+    "combining.d.ts",
+    "dist",
+    "lib",
+    "tools",
+    "examples",
+    "scripts/test-package.mjs",
+    "CHANGELOG.md",
+    "COMPATIBILITY.md",
+    "COMPATIBILITY_CONTRACT.md",
+    "CONTRIBUTING.md",
+    "LICENSE",
+    "MIGRATION.md",
+    "NOTICE",
+    "PUBLISHING.md",
+    "README.md",
+    "SECURITY.md",
+    "THIRD_PARTY_LICENSES.md",
+    "VERIFICATION.md",
+    "unicode-sources.json"
+  ],
+  "scripts": {
+    "clean": "node scripts/clean.mjs",
+    "build": "node scripts/build.mjs",
+    "lint": "eslint index.js index.mjs lib scripts test examples docs-site/*.js docs-site/*.mjs",
+    "docs:prepare": "node docs-site/prepare.mjs",
+    "docs:check": "node docs-site/check.mjs",
+    "unicode:generate": "node tools/generate-unicode-tables.mjs",
+    "unicode:check": "node tools/generate-unicode-tables.mjs --check",
+    "test:source": "npm run test:core && npm run test:release-helpers && npm run test:browser && npm run test:types",
+    "test:core": "node --test test/*.test.js",
+    "test:release-helpers": "node --test test/registry-verification.test.cjs",
+    "test:browser": "node scripts/check-browser.mjs",
+    "test:types": "tsc -p test/types/modern/tsconfig.json && node node_modules/typescript-3-9/bin/tsc -p test/types/legacy/tsconfig.json --typeRoots ./test/types/no-global-types",
+    "test": "node scripts/test-package.mjs",
+    "test:coverage": "c8 --all --include=index.js --include=lib/*.js --exclude=lib/unicode-tables.js --check-coverage --lines 95 --functions 95 --branches 90 node --test test/*.test.js",
+    "test:smoke": "node scripts/smoke-install.mjs",
+    "test:closure": "node scripts/check-production-closure.mjs",
+    "check:package": "publint --strict && attw --pack .",
+    "check:licenses": "node scripts/check-licenses.mjs",
+    "check:sbom": "node scripts/check-sbom.mjs",
+    "check:release": "node scripts/check-release.mjs",
+    "evidence:assemble": "node scripts/assemble-release-assets.mjs",
+    "evidence:check": "node scripts/check-release-assets.mjs",
+    "pack:check": "npm pack --dry-run",
+    "audit:dependencies": "npm audit --omit=dev --audit-level=low",
+    "audit:all": "npm audit --audit-level=low",
+    "audit:signatures": "npm audit signatures",
+    "verify": "npm run clean && npm run lint && npm run build && npm run docs:prepare && npm run docs:check && npm run unicode:check && npm test && npm run test:coverage && npm run test:smoke && npm run test:closure && npm run check:package && npm run check:licenses && npm run check:sbom && npm run check:release && npm run pack:check && npm run audit:dependencies && npm run audit:all && npm run audit:signatures",
+    "artifact:prepare": "node scripts/create-artifact.mjs",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@eslint/js": "10.0.1",
+    "@rollup/plugin-node-resolve": "16.0.3",
+    "c8": "12.0.0",
+    "esbuild": "0.28.2",
+    "eslint": "10.9.1",
+    "publint": "0.3.24",
+    "rollup": "4.63.1",
+    "typescript": "7.0.2",
+    "typescript-3-9": "npm:typescript@3.9.10",
+    "wcwidth-upstream": "npm:wcwidth@1.0.1"
+  },
+  "author": "Stackline maintainers",
+  "contributors": [
+    "Jun Woong (original wcwidth JavaScript port)"
+  ],
+  "homepage": "https://alexandro.net/docs/vanilla/wcwidth/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alexandroit/stackline-wcwidth.git"
+  },
+  "bugs": {
+    "url": "https://github.com/alexandroit/stackline-wcwidth/issues"
+  }
+}

package/scripts/test-package.mjs

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict'
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { createRequire } from 'node:module'
+
+const root = new URL('../', import.meta.url)
+
+if (existsSync(new URL('../test/api.test.js', import.meta.url))) {
+  if (!existsSync(new URL('../dist/index.mjs', import.meta.url))) runNpm(['run', 'build'])
+  runNpm(['run', 'test:source'])
+} else {
+  const require = createRequire(import.meta.url)
+  const wcwidth = require('../index.js')
+  const esm = await import(new URL('../dist/index.mjs', import.meta.url))
+
+  assert.equal(typeof wcwidth, 'function')
+  assert.deepEqual(Object.keys(wcwidth), ['config'])
+  assert.equal(wcwidth('A字🤦🏼‍♂️e\u0301'), 6)
+  assert.equal(wcwidth.config({ control: -1 })('a\nb'), -1)
+  assert.equal(esm.default('🇨🇦'), 2)
+  assert.equal(esm.config({ nul: 3 })('\0'), 3)
+  assert.equal(esm.unicodeVersion, '17.0.0')
+  process.stdout.write('Installed package CJS and ESM smoke tests passed.\n')
+}
+
+function runNpm(arguments_) {
+  const command = process.env.npm_execpath || 'npm'
+  const invocation = process.env.npm_execpath
+    ? [command, ...arguments_]
+    : arguments_
+  const result = spawnSync(process.env.npm_execpath ? process.execPath : command, invocation, {
+    cwd: root,
+    encoding: 'utf8',
+    stdio: 'inherit'
+  })
+  if (result.error) throw result.error
+  assert.equal(result.status, 0, `npm ${arguments_.join(' ')} failed`)
+}

package/tools/generate-unicode-tables.mjs

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+
+import { createHash } from 'node:crypto'
+import { access, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)))
+const manifestPath = join(root, 'unicode-sources.json')
+const outputPath = join(root, 'lib', 'unicode-tables.js')
+const graphemeTestPath = join(root, 'test', 'fixtures', 'GraphemeBreakTest.txt')
+const emojiTestPath = join(root, 'test', 'fixtures', 'emoji-test.txt')
+const check = process.argv.includes('--check')
+
+const manifest = JSON.parse(await readFile(manifestPath, 'utf8'))
+const scratch = await mkdtemp(join(tmpdir(), 'stackline-wcwidth-unicode-'))
+
+try {
+  const contents = {}
+  for (const [name, source] of Object.entries(manifest.sources)) {
+    const response = await fetch(source.url)
+    if (!response.ok) {
+      throw new Error(`Unable to download ${source.url}: HTTP ${response.status}`)
+    }
+
+    const bytes = Buffer.from(await response.arrayBuffer())
+    const actual = createHash('sha256').update(bytes).digest('hex')
+    if (actual !== source.sha256) {
+      throw new Error(`${name} checksum mismatch: expected ${source.sha256}, got ${actual}`)
+    }
+
+    await writeFile(join(scratch, name), bytes)
+    contents[name] = bytes.toString('utf8')
+  }
+
+  const generated = generateTables(manifest.version, contents)
+  const graphemeTests = contents['GraphemeBreakTest.txt']
+  const emojiTests = contents['emoji-test.txt']
+  const sourceTreeIncludesTests = await exists(dirname(graphemeTestPath))
+
+  if (check) {
+    const current = await readFile(outputPath, 'utf8')
+    if (current !== generated) {
+      throw new Error('lib/unicode-tables.js is not reproducible from unicode-sources.json')
+    }
+    if (sourceTreeIncludesTests) {
+      const currentGraphemeTests = await readFile(graphemeTestPath, 'utf8')
+      if (currentGraphemeTests !== graphemeTests) {
+        throw new Error('GraphemeBreakTest.txt does not match its pinned Unicode source')
+      }
+      const currentEmojiTests = await readFile(emojiTestPath, 'utf8')
+      if (currentEmojiTests !== emojiTests) {
+        throw new Error('emoji-test.txt does not match its pinned Unicode source')
+      }
+    }
+    process.stdout.write(`Unicode ${manifest.version} tables are current.\n`)
+  } else {
+    await writeFile(outputPath, generated)
+    if (sourceTreeIncludesTests) {
+      await writeFile(graphemeTestPath, graphemeTests)
+      await writeFile(emojiTestPath, emojiTests)
+    }
+    process.stdout.write(`Generated ${outputPath} from Unicode ${manifest.version}.\n`)
+  }
+} finally {
+  await rm(scratch, { recursive: true, force: true })
+}
+
+async function exists(pathname) {
+  try {
+    await access(pathname)
+    return true
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return false
+    throw error
+  }
+}
+
+function generateTables(version, files) {
+  const categories = parseUnicodeData(files['UnicodeData.txt'])
+  const zeroWidth = mergeRanges([
+    ...categories.Mn,
+    ...categories.Me,
+    ...categories.Cf,
+    [0x1160, 0x11ff],
+    [0xd7b0, 0xd7c6],
+    [0xd7cb, 0xd7fb]
+  ].flatMap((range) => subtractCodePoint(range, 0x00ad)))
+
+  const eastAsian = parseProperties(files['EastAsianWidth.txt'])
+  const wide = mergeRanges([...(eastAsian.W || []), ...(eastAsian.F || [])])
+
+  const grapheme = parseProperties(files['GraphemeBreakProperty.txt'])
+  const emoji = parseProperties(files['emoji-data.txt'])
+  const derived = parseProperties(files['DerivedCoreProperties.txt'], true)
+
+  const tables = {
+    ZERO_WIDTH: zeroWidth,
+    WIDE: wide,
+    EMOJI: emoji.Emoji || [],
+    EMOJI_PRESENTATION: emoji.Emoji_Presentation || [],
+    EXTENDED_PICTOGRAPHIC: emoji.Extended_Pictographic || [],
+    GCB_CR: grapheme.CR || [],
+    GCB_LF: grapheme.LF || [],
+    GCB_CONTROL: grapheme.Control || [],
+    GCB_EXTEND: grapheme.Extend || [],
+    GCB_ZWJ: grapheme.ZWJ || [],
+    GCB_REGIONAL_INDICATOR: grapheme.Regional_Indicator || [],
+    GCB_PREPEND: grapheme.Prepend || [],
+    GCB_SPACING_MARK: grapheme.SpacingMark || [],
+    GCB_L: grapheme.L || [],
+    GCB_V: grapheme.V || [],
+    GCB_T: grapheme.T || [],
+    GCB_LV: grapheme.LV || [],
+    GCB_LVT: grapheme.LVT || [],
+    INCB_CONSONANT: derived['InCB=Consonant'] || [],
+    INCB_EXTEND: derived['InCB=Extend'] || [],
+    INCB_LINKER: derived['InCB=Linker'] || []
+  }
+
+  const lines = [
+    "'use strict'",
+    '',
+    '// Generated by tools/generate-unicode-tables.mjs. Do not edit by hand.',
+    `const UNICODE_VERSION = ${JSON.stringify(version)}`,
+    ''
+  ]
+
+  for (const [name, ranges] of Object.entries(tables)) {
+    lines.push(`const ${name} = ${formatRanges(ranges)}`)
+  }
+
+  lines.push(
+    '',
+    'module.exports = {',
+    '  UNICODE_VERSION,',
+    ...Object.keys(tables).map((name) => `  ${name},`),
+    '}',
+    ''
+  )
+
+  return lines.join('\n')
+}
+
+function parseUnicodeData(text) {
+  const wanted = { Mn: [], Me: [], Cf: [] }
+  let pending = null
+
+  for (const line of text.split(/\r?\n/)) {
+    if (!line) continue
+    const fields = line.split(';')
+    const point = Number.parseInt(fields[0], 16)
+    const name = fields[1]
+    const category = fields[2]
+
+    if (name.endsWith(', First>')) {
+      pending = { point, category }
+      continue
+    }
+    if (name.endsWith(', Last>')) {
+      if (!pending || pending.category !== category) {
+        throw new Error(`Malformed UnicodeData range ending at ${fields[0]}`)
+      }
+      if (wanted[category]) wanted[category].push([pending.point, point])
+      pending = null
+      continue
+    }
+    if (wanted[category]) wanted[category].push([point, point])
+  }
+
+  if (pending) throw new Error('Unclosed UnicodeData range')
+  return wanted
+}
+
+function parseProperties(text, compound = false) {
+  const properties = {}
+
+  for (const original of text.split(/\r?\n/)) {
+    const line = original.replace(/#.*/, '').trim()
+    if (!line || line.startsWith('@missing:')) continue
+    const fields = line.split(';').map((field) => field.trim())
+    if (fields.length < 2) continue
+
+    const property = compound && fields[1] === 'InCB'
+      ? `${fields[1]}=${fields[2]}`
+      : fields[1]
+    if (!property) continue
+
+    const [first, last = first] = fields[0].split('..')
+    const range = [Number.parseInt(first, 16), Number.parseInt(last, 16)]
+    ;(properties[property] ||= []).push(range)
+  }
+
+  for (const [name, ranges] of Object.entries(properties)) {
+    properties[name] = mergeRanges(ranges)
+  }
+  return properties
+}
+
+function subtractCodePoint([start, end], point) {
+  if (point < start || point > end) return [[start, end]]
+  const result = []
+  if (start < point) result.push([start, point - 1])
+  if (point < end) result.push([point + 1, end])
+  return result
+}
+
+function mergeRanges(ranges) {
+  const sorted = ranges
+    .map(([start, end]) => [start, end])
+    .sort((a, b) => a[0] - b[0] || a[1] - b[1])
+  const merged = []
+
+  for (const range of sorted) {
+    const previous = merged.at(-1)
+    if (previous && range[0] <= previous[1] + 1) {
+      previous[1] = Math.max(previous[1], range[1])
+    } else {
+      merged.push(range)
+    }
+  }
+  return merged
+}
+
+function formatRanges(ranges) {
+  if (ranges.length === 0) return '[]\n'
+  const values = ranges.map(([start, end]) => `[0x${start.toString(16)},0x${end.toString(16)}]`)
+  const rows = []
+  for (let index = 0; index < values.length; index += 5) {
+    rows.push(`  ${values.slice(index, index + 5).join(',')}`)
+  }
+  return `[\n${rows.join(',\n')}\n]\n`
+}

package/unicode-sources.json

@@ -0,0 +1,33 @@
+{
+  "version": "17.0.0",
+  "sources": {
+    "UnicodeData.txt": {
+      "url": "https://www.unicode.org/Public/17.0.0/ucd/UnicodeData.txt",
+      "sha256": "2e1efc1dcb59c575eedf5ccae60f95229f706ee6d031835247d843c11d96470c"
+    },
+    "EastAsianWidth.txt": {
+      "url": "https://www.unicode.org/Public/17.0.0/ucd/EastAsianWidth.txt",
+      "sha256": "ea7ce50f3444a050333448dffef1cadd9325af55cbb764b4a2280faf52170a33"
+    },
+    "GraphemeBreakProperty.txt": {
+      "url": "https://www.unicode.org/Public/17.0.0/ucd/auxiliary/GraphemeBreakProperty.txt",
+      "sha256": "d6b51d1d2ae5c33b451b7ed994b48f1f4dc62b2272a5831e7fd418514a6bae89"
+    },
+    "emoji-data.txt": {
+      "url": "https://www.unicode.org/Public/17.0.0/ucd/emoji/emoji-data.txt",
+      "sha256": "2cb2bb9455cda83e8481541ecf5b6dfda66a3bb89efa3fa7c5297eccf607b72b"
+    },
+    "DerivedCoreProperties.txt": {
+      "url": "https://www.unicode.org/Public/17.0.0/ucd/DerivedCoreProperties.txt",
+      "sha256": "24c7fed1195c482faaefd5c1e7eb821c5ee1fb6de07ecdbaa64b56a99da22c08"
+    },
+    "GraphemeBreakTest.txt": {
+      "url": "https://www.unicode.org/Public/17.0.0/ucd/auxiliary/GraphemeBreakTest.txt",
+      "sha256": "e2d134d2c52919bace503ebb6a551c1855fe1a1faec18478c78fff254a1793ec"
+    },
+    "emoji-test.txt": {
+      "url": "https://www.unicode.org/Public/17.0.0/emoji/emoji-test.txt",
+      "sha256": "1d8a944f88d7952f7ef7c5167fef3c67995bcae24543949710231b03a201acda"
+    }
+  }
+}