Skip to content

code-yeongyu/oh-my-openagent / packages/shared-skills/skills/ulw-research

ulw-research

Unverified

Runs maximum-saturation research with a cooperating team, claim-graph gating, and a cited, QA'd deliverable. Use when the user explicitly asks for research or a deep investigation, including any 'ulw' research wording.

FileKindSize
AGENTS.mdmarkdown9.2 KB
ATTRIBUTION.mdmarkdown2.4 KB
SKILL.mdskill md42.2 KB
references/deliverable-phase.mdmarkdown49.1 KB
references/fact-ledger-grammar.mdmarkdown6.8 KB
references/fact-ledger.mdmarkdown24.4 KB
references/fidelity-claim-kinds.mdmarkdown5.2 KB
references/markdown-blocks.mdmarkdown721 B
references/report-gates.mdmarkdown32.0 KB
references/report-visualization.mdmarkdown15.4 KB
references/research-collection.mdmarkdown26.8 KB
references/research-delivery.mdmarkdown14.3 KB
references/unit-rules.mdmarkdown16.3 KB
scripts/claim-kinds.mjsscript11.2 KB
scripts/claim-kinds.test.tsscript13.5 KB
scripts/claim-prefix.test.tsscript4.9 KB
scripts/claims-index.mjsscript5.3 KB
scripts/claims-index.test.tsscript5.7 KB
scripts/cli-support.mjsscript4.1 KB
scripts/cli-support.test.tsscript4.3 KB
scripts/contracts-validation.test.tsscript3.3 KB
scripts/contracts.mjsscript26.1 KB
scripts/contracts.test.tsscript7.9 KB
scripts/conversion-altered.test.tsscript11.0 KB
scripts/conversion-originals.test.tsscript22.7 KB
scripts/conversion-probe-classes.test.tsscript45.2 KB
scripts/conversion-probe.mjsscript13.5 KB
scripts/conversion-probe.test.tsscript11.6 KB
scripts/copy-returns-fidelity-policy.test.tsscript10.4 KB
scripts/copy-returns-polish.test.tsscript12.1 KB
scripts/copy-returns.test.tsscript10.6 KB
scripts/css-hiding.mjsscript9.1 KB
scripts/css-lite.mjsscript7.6 KB
scripts/css-lite.test.tsscript6.4 KB
scripts/delivery-barrier-meaning.test.tsscript12.3 KB
scripts/delivery-barrier.test.tsscript11.4 KB
scripts/design-spec.mjsscript7.2 KB
scripts/design-spec.test.tsscript6.7 KB
scripts/entities.mjsscript2.5 KB
scripts/entry-guard.mjsscript794 B
scripts/fact-commands-fill.mjsscript6.6 KB
scripts/fact-commands-meaning.mjsscript12.6 KB
scripts/fact-commands-polish.mjsscript10.3 KB
scripts/fact-commands-verify.mjsscript12.6 KB
scripts/fact-commands.mjsscript13.8 KB
scripts/fact-derive-2.test.tsscript7.2 KB
scripts/fact-derive.mjsscript4.9 KB
scripts/fact-derive.test.tsscript10.8 KB
scripts/fact-expr.mjsscript4.5 KB
scripts/fact-fill.mjsscript11.7 KB
scripts/fact-fill.test.tsscript10.7 KB
scripts/fact-ledger-grammar.test.tsscript11.8 KB
scripts/fact-ledger-kinds.mjsscript16.5 KB
scripts/fact-ledger-kinds.test.tsscript9.3 KB
scripts/fact-ledger-legacy.test.tsscript8.9 KB
scripts/fact-ledger-schema.mjsscript11.9 KB
scripts/fact-ledger-schema.test.tsscript1.5 KB
scripts/fact-ledger.mjsscript5.5 KB
scripts/fact-ledger.test.tsscript9.7 KB
scripts/fact-locate.mjsscript12.1 KB
scripts/fact-locate.test.tsscript7.2 KB
scripts/fact-pairs.mjsscript8.3 KB
scripts/fact-pairs.test.tsscript6.6 KB
scripts/fact-recompute.mjsscript4.8 KB
scripts/fact-unit-dimensions-2.test.tsscript8.4 KB
scripts/fact-unit-dimensions.test.tsscript11.9 KB
scripts/fact-unit-rules.test.tsscript8.9 KB
scripts/fidelity-binding.mjsscript6.7 KB
scripts/fidelity-binding.test.tsscript4.0 KB
scripts/fidelity-brief.mjsscript6.4 KB
scripts/fidelity-brief.test.tsscript7.8 KB
scripts/fidelity-claims.mjsscript5.1 KB
scripts/fidelity-csv.mjsscript1.1 KB
scripts/fidelity-lexicon.mjsscript8.1 KB
scripts/fidelity-lexicon.test.tsscript6.0 KB
scripts/fidelity-originals.mjsscript9.9 KB
scripts/fidelity-policy.mjsscript10.1 KB
scripts/fidelity-records.mjsscript13.4 KB
scripts/fidelity-snapshot-readability.mjsscript2.2 KB
scripts/fidelity-sources.mjsscript4.3 KB
scripts/fidelity-state.mjsscript2.1 KB
scripts/fidelity-state.test.tsscript1.7 KB
scripts/fidelity-trace.mjsscript6.1 KB
scripts/fidelity-trace.test.tsscript3.3 KB
scripts/fidelity-value-unit.mjsscript13.3 KB
scripts/fidelity-values.mjsscript16.1 KB
scripts/fidelity-values.test.tsscript15.8 KB
scripts/format-extract-css.mjsscript5.1 KB
scripts/format-extract.mjsscript10.3 KB
scripts/format-extract.test.tsscript11.2 KB
scripts/gates-context.test.tsscript2.6 KB
scripts/gates-fidelity.mjsscript6.3 KB
scripts/gates-fidelity.test.tsscript3.3 KB
scripts/gates-figures.mjsscript9.9 KB
scripts/gates-layout.mjsscript6.6 KB
scripts/gates-layout.test.tsscript12.4 KB
scripts/gates-static-headings.test.tsscript961 B
scripts/gates-static.mjsscript8.1 KB
scripts/gates-static.test.tsscript14.9 KB
scripts/gates-structure.mjsscript4.7 KB
scripts/gates-text.mjsscript7.2 KB
scripts/glossary-vocabulary.test.tsscript1.7 KB
scripts/html-foreign-object.mjsscript2.8 KB
scripts/html-lite.mjsscript9.7 KB
scripts/html-lite.test.tsscript7.9 KB
scripts/html-markup.mjsscript7.0 KB
scripts/html-text-map.mjsscript4.8 KB
scripts/html-text-map.test.tsscript15.2 KB
scripts/layout-probe.mjsscript4.6 KB
scripts/layout-probe.test.tsscript4.2 KB
scripts/lexicon.mjsscript2.6 KB
scripts/lexicon.test.tsscript3.2 KB
scripts/markdown-closers.mjsscript4.9 KB
scripts/md-lite-boundaries.test.tsscript2.2 KB
scripts/md-lite.mjsscript7.8 KB
scripts/md-lite.test.tsscript10.3 KB
scripts/meaning-check.mjsscript9.7 KB
scripts/meaning-check.test.tsscript12.0 KB
scripts/number-grammar.mjsscript2.1 KB
scripts/number-grammar.test.tsscript1.8 KB
scripts/numerals.mjsscript12.0 KB
scripts/numerals.test.tsscript6.1 KB
scripts/outcome-start.mjsscript3.8 KB
scripts/outcome-start.test.tsscript5.0 KB
scripts/outcome.mjsscript10.5 KB
scripts/outcome.test.tsscript12.8 KB
scripts/page-source-locator.test.tsscript11.7 KB
scripts/particles-ko.mjsscript4.8 KB
scripts/particles-ko.test.tsscript4.3 KB
scripts/placeholder.mjsscript9.3 KB
scripts/placeholder.test.tsscript3.8 KB
scripts/polish-apply.mjsscript6.8 KB
scripts/polish-apply.test.tsscript19.7 KB
scripts/polish-diff.mjsscript1.7 KB
scripts/polish-diff.test.tsscript10.1 KB
scripts/polish-markup.test.tsscript14.0 KB
scripts/polish-partial.test.tsscript2.5 KB
scripts/polish-project.mjsscript5.8 KB
scripts/polish-rules.mjsscript9.8 KB
scripts/rational.mjsscript5.2 KB
scripts/rational.test.tsscript1.9 KB
scripts/raw-decode.mjsscript4.5 KB
scripts/raw-locator.mjsscript2.4 KB
scripts/raw-snapshot.test.tsscript7.3 KB
scripts/references-fences.test.tsscript1.2 KB
scripts/repair-tracker.mjsscript7.5 KB
scripts/repair-tracker.test.tsscript10.8 KB
scripts/report-tools-2.test.tsscript16.1 KB
scripts/report-tools-3.test.tsscript9.3 KB
scripts/report-tools-4.test.tsscript10.1 KB
scripts/report-tools-5.test.tsscript14.6 KB
scripts/report-tools-commands.mjsscript12.9 KB
scripts/report-tools.mjsscript2.6 KB
scripts/report-tools.test.tsscript12.1 KB
scripts/sentence-split.mjsscript3.0 KB
scripts/sentence-split.test.tsscript4.5 KB
scripts/snapshot-readability.test.tsscript7.0 KB
scripts/source-commands.mjsscript12.4 KB
scripts/source-integrity.test.tsscript18.1 KB
scripts/source-refresh.mjsscript5.2 KB
scripts/source-snapshot.mjsscript9.9 KB
scripts/source-snapshot.test.tsscript6.3 KB
scripts/source-view.mjsscript5.0 KB
scripts/sources-citation.mjsscript12.1 KB
scripts/sources-citation.test.tsscript14.8 KB
scripts/tests/contracts-support.tsscript3.5 KB
scripts/tests/delivery-barrier-session.tsscript3.3 KB
scripts/tests/derive-clock.tsscript341 B
scripts/tests/fact-derive-support.tsscript1.9 KB
scripts/tests/fact-unit-dimensions-support.tsscript1.5 KB
scripts/tests/fact-unit-rules-support.tsscript16.8 KB
scripts/tests/fidelity-values-support.tsscript1.6 KB
scripts/tests/fixtures/assets/figure-1.svgother141 B
scripts/tests/fixtures/bad-report.htmlother2.1 KB
scripts/tests/fixtures/boxes.jsonconfig3.2 KB
scripts/tests/fixtures/conversion-probe.htmlother485 B
scripts/tests/fixtures/design-spec.mdmarkdown458 B
scripts/tests/fixtures/fidelity-brief-locked.mdmarkdown571 B
scripts/tests/fixtures/fidelity-brief-pending.mdmarkdown574 B
scripts/tests/fixtures/fidelity/assets/share.csvother40 B
scripts/tests/fixtures/fidelity/claim-graph.mdmarkdown449 B
scripts/tests/fixtures/fidelity/gen-legacy-dev.mjsscript5.0 KB
scripts/tests/fixtures/fidelity/ledger-basic.jsonconfig5.1 KB
scripts/tests/fixtures/fidelity/ledger-legacy-dev.jsonconfig18.3 KB
scripts/tests/fixtures/fidelity/ledger-verify.jsonconfig9.1 KB
scripts/tests/fixtures/fidelity/polish-edits.jsonconfig303 B
scripts/tests/fixtures/fidelity/report-bad.htmlother821 B
scripts/tests/fixtures/fidelity/report-good.htmlother2.4 KB
scripts/tests/fixtures/fidelity/sources/S4.htmlother680 B
scripts/tests/fixtures/fidelity/sources/S4/acronyms.jsonconfig36 B
scripts/tests/fixtures/fidelity/sources/S4/meta.jsonconfig256 B
scripts/tests/fixtures/fidelity/sources/S4/sentences.jsonlother623 B
scripts/tests/fixtures/fidelity/sources/S4/text.txtmarkdown300 B
scripts/tests/fixtures/fidelity/sources/S5/acronyms.jsonconfig3 B
scripts/tests/fixtures/fidelity/sources/S5/meta.jsonconfig235 B
scripts/tests/fixtures/fidelity/sources/S5/sentences.jsonlother53 B
scripts/tests/fixtures/fidelity/sources/S5/text.txtmarkdown10 B
scripts/tests/fixtures/fidelity/sources/S9.txtmarkdown128 B
scripts/tests/fixtures/good-report.htmlother2.7 KB
scripts/tests/fixtures/reference-report.htmlother2.5 KB

scripts/numerals.mjs

View on GitHub
// numerals.mjs - shared numeral patterns and the numeral parser.
//
// NUM, UNIT, NOT_CLAIMS and CLAIMS are the claim-detection patterns the unsourced-number gate uses
// (gates-text.mjs imports them from here). parseNumeral reads one numeral into an exact decimal
// string: thousands separators, Korean and Latin scale words, percent and percentage points, the
// English number words one to twelve, an adjacent currency symbol or unit, and an adjacent bounding
// qualifier. No numeral is ever passed through Number(). Plain Node ESM, sibling imports only.

import { groupedNumberSource } from "./number-grammar.mjs"
import { add, fromDecimal, mul, toDecimal } from "./rational.mjs"
import { normalizeUnit } from "./units.mjs"

/** European digit grouping ("1.234.567"): two or more dot groups of three digits, never a version. */
export const DOT_GROUPED = "\\d{1,3}(?:\\.\\d{3}){2,}"
const MONTH = "(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\\.?"
/** Stripped before claim detection: dates, versions, figure refs, times, bare years. */
export const NOT_CLAIMS = [
  /\b\d{4}[-./]\d{1,2}(?:[-./]\d{1,2})?\b/g,
  /\b\d{2}\.\d{2}\.\d{2}\b/g,
  /\d{2,4}\s*\uB144\s*\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
  /\d{1,2}\s*\uC6D4(?:\s*\d{1,2}\s*\uC77C)?/g,
  /(?:19|20)\d{2}\s*\uB144/g,
  new RegExp(`\\b${MONTH}\\s+\\d{1,2}(?:st|nd|rd|th)?(?:,?\\s+\\d{4})?`, "gi"),
  new RegExp(`\\b\\d{1,2}(?:st|nd|rd|th)?\\s+${MONTH}(?:\\s+\\d{4})?`, "gi"),
  new RegExp(`\\bv\\d+(?:\\.\\d+)*\\b|\\b(?!${DOT_GROUPED}(?![\\d,]|\\.\\d))\\d+(?:\\.\\d+){2,}\\b`, "gi"),
  /\b(?:version|ver\.?|release)\s*\d+(?:\.\d+)*/gi,
  /\b(?:fig(?:ure)?\.?|table|chart|section|step|phase|wave|part)\s*\d+(?:\.\d+)*/gi,
  /(?:\uADF8\uB9BC|\uB3C4\uD45C|\uD45C|\uBC84\uC804)\s*\d+(?:\.\d+)*/g,
  /\b\d{1,2}:\d{2}\b/g,
  /\b(?:19|20)\d{2}s?\b/g,
]
export const NUM = "(?<![\\p{L}\\d.,])\\d+(?:[.,]\\d+)*"
export const UNIT =
  "(?:%|\\u2030|\\u00D7|\\uD37C\\uC13C\\uD2B8|\\uB2EC\\uB7EC|\\uC720\\uB85C|\\uC5D4|\\uC6D0|\\uB9CC|\\uC5B5|\\uC870|\\uCC9C|\\uCD08|\\uBD84|\\uC2DC\\uAC04|\\uC77C|\\uC8FC|\\uAC1C\\uC6D4|\\uB144|\\uBA85|\\uAC74|\\uAC1C|\\uD68C|\\uBC88|\\uBC30" +
  "|(?:percent|pp|bps?|x|k|m|b|bn|million|billion|thousand|trillion|usd|krw|eur|ms|s|secs?|seconds?|mins?|minutes?|h|hrs?|hours?|days?|weeks?|months?|years?|kb|mb|gb|tb|users?|people|employees|engineers|tokens?|requests?|stars?|downloads?|customers?)(?![\\p{L}\\d]))"
export const CLAIMS = [
  new RegExp(`[$\\u20AC\\u00A3\\u00A5\\u20A9]\\s?${NUM}`, "u"),
  new RegExp(`${NUM}\\s?${UNIT}`, "iu"),
  /(?<![\d.,])\d{1,3}(?:,\d{3})+(?![\d,])/,
  /(?<![\d.])\d+\.\d+(?![\d.])/,
]

const WORDS = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve"]
const WORD_RE = new RegExp(`\\b(?:${WORDS.join("|")})\\b`, "gi")
/** Korean scale words: cheon (1e3) inside a group, then man, eok, jo as group scales. */
const CHEON = "\uCC9C"
const BIG = new Map([
  ["\uB9CC", 10000n],
  ["\uC5B5", 100000000n],
  ["\uC870", 1000000000000n],
])
/** A scale word that starts a longer word is not a scale: jogak (pieces), mankeum (as much as). */
const KO_GROUP = /^(\s?)(?:(\uCC9C)?([\uB9CC\uC5B5\uC870])|(\uCC9C))(?![\uAC01\uD07C])/
const KO_NEXT = new RegExp(`^\\s?(${NUM})(\uCC9C)?([\uB9CC\uC5B5\uC870])?`, "u")
const LATIN_SCALE = /^(?:(k|K|M|mn|bn|B)|\s(thousand|million|billion|trillion|mn|bn))(?![\p{L}\d])/u
const LATIN_FACTOR = {
  k: 1000n,
  K: 1000n,
  M: 1000000n,
  mn: 1000000n,
  bn: 1000000000n,
  B: 1000000000n,
  thousand: 1000n,
  million: 1000000n,
  billion: 1000000000n,
  trillion: 1000000000000n,
}
const CURRENCY = "$\u20AC\u00A3\u00A5\u20A9"
const SYMBOL_UNIT = /^\s?(%p|%|\u2030|\u00D7|\u00B0C|\u00B0F|\u2103|\u2109)/
const LATIN_UNIT = /^\s?([A-Za-z]+)(?![\p{L}\d])/u
const HANGUL_UNIT = /^\s?([\uAC00-\uD7A3]+)/
/** "3 bun-ui 1" is the fraction one third, not 3 minutes. */
const FRACTION = /^\s?\uBD84\uC758\s?\d/
const UNIT_AFTER = new RegExp(`^\\s?${UNIT}`, "iu")
const NUM_AT = new RegExp(`^${NUM}`, "u")
/** Range separators: hyphen, en dash, tilde, "to". */
const RANGE_SEP = /^(?:\s?[-\u2013~]\s?|\sto\s)/
const SIGN = "-\u2212"
/** Bounding qualifiers: before the value (Korean and English) and right after it (Korean). */
const QUALIFIERS_BEFORE = [
  "up to",
  "at least",
  "at most",
  "more than",
  "less than",
  "about",
  "approximately",
  "nearly",
  "over",
  "under",
  "\uCD5C\uB300",
  "\uCD5C\uC18C",
  "\uC57D",
]
/** Korean bounding qualifiers written right after a value (isang, iha, miman, chogwa, naeoe, kkaji). */
export const QUALIFIERS_AFTER = Object.freeze([
  "\uC774\uC0C1",
  "\uC774\uD558",
  "\uBBF8\uB9CC",
  "\uCD08\uACFC",
  "\uB0B4\uC678",
  "\uAE4C\uC9C0",
])
const QUALIFIER_AFTER = new RegExp(`^\\s?(${QUALIFIERS_AFTER.join("|")})`)

/** Comma grouping from the one grouped-number grammar (number-grammar.mjs). */
const COMMA_GROUPED = new RegExp(`^${groupedNumberSource([","])}$`)

/** "1,237" -> "1237"; a malformed group ("1,23", "12,3451") keeps only the leading plain number. */
function cleanDigits(raw) {
  if (COMMA_GROUPED.test(raw)) return { digits: raw.replace(/,/g, ""), length: raw.length }
  const plain = /^\d+(?:\.\d+)?/.exec(raw)[0]
  return { digits: plain, length: plain.length }
}

/** A numeral's digits, reading a European period grouping ("1.234.567") as one integer. */
const digitsOf = (raw) =>
  new RegExp(`^${DOT_GROUPED}$`).test(raw) ? { digits: raw.replace(/\./g, ""), length: raw.length } : cleanDigits(raw)

/** The bare-year and four-digit-date patterns: a numeral they cover can still be a value. */
const YEAR_SHAPED = new Set([NOT_CLAIMS[0], NOT_CLAIMS[12]])

function excludedRanges(text) {
  const ranges = []
  for (const re of NOT_CLAIMS) {
    for (const match of text.matchAll(re))
      ranges.push([match.index, match.index + match[0].length, YEAR_SHAPED.has(re)])
  }
  return ranges
}

/** A year-shaped numeral is a value when it has a decimal part or a currency, scale word or unit touches it. */
function anchored(text, at, end, digits) {
  if (digits.includes(".") || (at > 0 && CURRENCY.includes(text[at - 1]))) return true
  return UNIT_AFTER.test(text.slice(end)) || unitAfter(text, end) !== null
}

/**
 * First digit run or number word at or after `from` that no NOT_CLAIMS pattern covers. A year-shaped
 * match exactly over the numeral (not "2020s", not "2020-03") is lifted when the numeral is anchored.
 */
function findStart(text, from, ranges) {
  const covering = (at) => ranges.filter(([s, e]) => at >= s && at < e)
  let digit = null
  for (const match of text.slice(from).matchAll(new RegExp(NUM, "gu"))) {
    const at = from + match.index
    const candidate = { at, ...digitsOf(match[0]) }
    const end = at + candidate.length
    const cover = covering(at)
    const lifted = cover.every(([s, e, yearShaped]) => yearShaped && s === at && e <= end)
    if (cover.length === 0 || (lifted && anchored(text, at, end, candidate.digits))) {
      digit = candidate
      break
    }
  }
  const free = (at) => covering(at).length === 0
  for (const match of text.slice(from).matchAll(WORD_RE)) {
    const at = from + match.index
    if (digit && digit.at < at) break
    if (free(at)) return { at, digits: String(WORDS.indexOf(match[0].toLowerCase()) + 1), length: match[0].length }
  }
  return digit
}

/** Korean groups such as "4jo 2,000eok": each later group needs a smaller scale. */
function koreanScale(text, at, digits) {
  const first = KO_GROUP.exec(text.slice(at))
  if (!first) return null
  const big = first[3] ? BIG.get(first[3]) : 1n
  const firstFactor = (first[2] || first[4] ? 1000n : 1n) * big
  let value = mul(fromDecimal(digits), firstFactor)
  let end = at + first[0].length
  let last = first[3] ? big : 0n
  let groups = 1
  while (last > 1n) {
    const next = KO_NEXT.exec(text.slice(end))
    if (!next) break
    const factor = (next[2] ? 1000n : 1n) * (next[3] ? BIG.get(next[3]) : 1n)
    if (factor <= 1n || factor >= last) break
    value = add(value, mul(fromDecimal(cleanDigits(next[1]).digits), factor))
    end += next[0].length
    last = next[3] ? BIG.get(next[3]) : 0n
    groups++
  }
  return { value, end, factor: groups === 1 ? firstFactor : null }
}

/** Scale words after a numeral: { value (rational) | null, end, factor | null (one plain factor) }. */
function scaled(text, end, digits) {
  const korean = koreanScale(text, end, digits)
  if (korean) return korean
  const latin = LATIN_SCALE.exec(text.slice(end))
  if (!latin) return { value: null, end, factor: null }
  const factor = LATIN_FACTOR[latin[1] ?? latin[2].toLowerCase()]
  return { value: mul(fromDecimal(digits), factor), end: end + latin[0].length, factor }
}

/** The second endpoint of "5-10", "5 to 10", "5~10" or "5\u201310", or null. */
function rangeEnd(text, at, ranges) {
  const sep = RANGE_SEP.exec(text.slice(at))
  if (!sep) return null
  const pos = at + sep[0].length
  const num = NUM_AT.exec(text.slice(pos))
  if (!num || ranges.some(([s, e]) => pos >= s && pos < e)) return null
  const { digits, length } = cleanDigits(num[0])
  const scale = scaled(text, pos + length, digits)
  return { value: scale.value ? toDecimal(scale.value) : digits, end: scale.end, factor: scale.factor }
}

function unitAfter(text, at) {
  const rest = text.slice(at)
  if (FRACTION.test(rest)) return null
  const symbol = SYMBOL_UNIT.exec(rest)
  if (symbol) return { unitRaw: symbol[1], end: at + symbol[0].length }
  const latin = LATIN_UNIT.exec(rest)
  if (latin) return normalizeUnit(latin[1]) ? { unitRaw: latin[1], end: at + latin[0].length } : null
  const hangul = HANGUL_UNIT.exec(rest)
  if (!hangul) return null
  const lead = hangul[0].length - hangul[1].length
  for (let size = hangul[1].length; size > 0; size--) {
    const candidate = hangul[1].slice(0, size)
    if (!BIG.has(candidate) && candidate !== CHEON && normalizeUnit(candidate))
      return { unitRaw: candidate, end: at + lead + size }
  }
  return null
}

function qualifierBefore(text, at) {
  const tokens = text
    .slice(0, at)
    .trim()
    .split(/\s+/)
    .slice(-2)
    .map((token) => token.replace(/^[^\p{L}]+/u, ""))
  for (const phrase of QUALIFIERS_BEFORE) {
    const words = phrase.split(" ")
    for (let skip = 0; skip + words.length <= tokens.length; skip++) {
      const window = tokens.slice(tokens.length - skip - words.length, tokens.length - skip)
      if (window.join(" ").toLowerCase() === phrase) return window.join(" ")
    }
  }
  return null
}

/**
 * The first numeral at or after `from`: { value, raw, span: [start, end], unitRaw, qualifierRaw },
 * or null. `value` is an exact decimal string with scale words folded in ("3eok won" -> "300000000",
 * unit "won") and a leading minus sign ("-" or U+2212) kept as "-"; `span` covers the sign, an
 * adjacent currency symbol, the numeral, scale words and the unit. A range ("5-10 m", "5 to 10 m",
 * "5~10%") adds `valueEnd` and `range: true`; the unit, and a scale word written only on the second
 * endpoint ("3~5eok"), apply to both endpoints.
 */
export function parseNumeral(text, from = 0) {
  const ranges = excludedRanges(text)
  const found = findStart(text, from, ranges)
  if (!found) return null
  let start = found.at
  const first = scaled(text, found.at + found.length, found.digits)
  let value = first.value
  let end = first.end
  const second = rangeEnd(text, end, ranges)
  if (second) {
    end = second.end
    if (!value && second.factor) value = mul(fromDecimal(found.digits), second.factor)
  }
  let unitRaw = null
  if (start > 0 && CURRENCY.includes(text[start - 1])) [unitRaw, start] = [text[start - 1], start - 1]
  const negative = start > 0 && SIGN.includes(text[start - 1]) && !/[\p{L}\p{N}]/u.test(text[start - 2] ?? "")
  if (negative) start--
  const unit = unitRaw ? null : unitAfter(text, end)
  if (unit) [unitRaw, end] = [unit.unitRaw, unit.end]
  const after = QUALIFIER_AFTER.exec(text.slice(end))
  return {
    value: (negative ? "-" : "") + (value ? toDecimal(value) : found.digits),
    ...(second ? { valueEnd: second.value, range: true } : {}),
    raw: text.slice(start, end),
    span: [start, end],
    unitRaw,
    qualifierRaw: qualifierBefore(text, start) ?? (after ? after[1] : null),
  }
}
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 198kUpdated Claude CodeCodexVerifiedInstall